/// <summary>
        /// Return a clone of this neural network. Including structure, weights and
        /// threshold values.
        /// </summary>
        /// <returns>A cloned copy of the neural network.</returns>
        public Object Clone()
        {
            FeedforwardNetwork result = CloneStructure();

            Double[] copy = MatrixCODEC.NetworkToArray(this);
            MatrixCODEC.ArrayToNetwork(copy, result);
            return(result);
        }
        /// <summary>
        /// Return a clone of the structure of this neural network.
        /// </summary>
        /// <returns>A cloned copy of the structure of the neural network.</returns>

        public FeedforwardNetwork CloneStructure()
        {
            FeedforwardNetwork result = new FeedforwardNetwork();

            foreach (FeedforwardLayer layer in this.layers)
            {
                FeedforwardLayer clonedLayer = new FeedforwardLayer(layer.NeuronCount);
                result.AddLayer(clonedLayer);
            }

            return(result);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Convert from an array.  Use an array to populate the memory of the neural network.
        /// </summary>
        /// <param name="array">An array that will hold the memory of the neural network.</param>
        /// <param name="network">A neural network to convert to an array.</param>
        public static void ArrayToNetwork(Double[] array,
                FeedforwardNetwork network)
        {

            // copy data to array
            int index = 0;

            foreach (FeedforwardLayer layer in network.Layers)
            {

                // now the weight matrix(if it exists)
                if (layer.Next != null)
                {
                    index = layer.LayerMatrix.FromPackedArray(array, index);
                }
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Convert to an array. This is used with some training algorithms that
        /// require that the "memory" of the neuron(the weight and threshold values)
        /// be expressed as a linear array.
        /// </summary>
        /// <param name="network">A neural network.</param>
        /// <returns>The memory of the neural network as an array.</returns>
        public static double[] NetworkToArray(FeedforwardNetwork network)
        {
            int size = 0;

            // first determine size
            foreach (FeedforwardLayer layer in network.Layers)
            {
                // count the size of the weight matrix
                if (layer.HasMatrix())
                {
                    size += layer.MatrixSize;
                }
            }

            // allocate an array to hold
            Double[] result = new Double[size];

            // copy data to array
            int index = 0;

            foreach (FeedforwardLayer layer in network.Layers)
            {

                // now the weight matrix(if it exists)
                if (layer.Next != null)
                {

                    Double[] matrix = layer.LayerMatrix.ToPackedArray();
                    for (int i = 0; i < matrix.Length; i++)
                    {
                        result[index++] = matrix[i];
                    }
                }
            }

            return result;
        }
        /// <summary>
        /// Compare the two neural networks. For them to be equal they must be of the
        /// same structure, and have the same matrix values.
        /// </summary>
        /// <param name="other">The other neural network.</param>
        /// <returns>True if the two networks are equal.</returns>
        public bool Equals(FeedforwardNetwork other)
        {
            int i = 0;

            foreach (FeedforwardLayer layer in this.Layers)
            {
                FeedforwardLayer otherLayer = other.Layers[i++];

                if (layer.NeuronCount != otherLayer.NeuronCount)
                {
                    return(false);
                }

                // make sure they either both have or do not have
                // a weight matrix.
                if ((layer.LayerMatrix == null) && (otherLayer.LayerMatrix != null))
                {
                    return(false);
                }

                if ((layer.LayerMatrix != null) && (otherLayer.LayerMatrix == null))
                {
                    return(false);
                }

                // if they both have a matrix, then compare the matrices
                if ((layer.LayerMatrix != null) && (otherLayer.LayerMatrix != null))
                {
                    if (!layer.LayerMatrix.Equals(otherLayer.LayerMatrix))
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Method that is called to start the incremental prune process.
        /// </summary>
        public void StartIncremental()
        {
            this.hiddenNeuronCount = 1;
            this.cycles = 0;
            this.done = false;

            this.currentNetwork = new FeedforwardNetwork();
            this.currentNetwork
                    .AddLayer(new FeedforwardLayer(this.train[0].Length));
            this.currentNetwork.AddLayer(new FeedforwardLayer(
                    this.hiddenNeuronCount));
            this.currentNetwork
                    .AddLayer(new FeedforwardLayer(this.ideal[0].Length));
            this.currentNetwork.Reset();

            this.backprop = new Backpropagation(this.currentNetwork, this.train,
                    this.ideal, this.rate, this.momentum);

        }
Exemplo n.º 7
0
        /// <summary>
        /// Internal method that is called at the end of each incremental cycle.
        /// </summary>
        protected void Increment()
        {
            bool doit = false;

            if (this.markErrorRate == 0)
            {
                this.markErrorRate = this.error;
                this.sinceMark = 0;
            }
            else
            {
                this.sinceMark++;
                if (this.sinceMark > 10000)
                {
                    if ((this.markErrorRate - this.error) < 0.01)
                    {
                        doit = true;
                    }
                    this.markErrorRate = this.error;
                    this.sinceMark = 0;
                }
            }

            if (this.error < this.maxError)
            {
                this.done = true;
            }

            if (doit)
            {
                this.cycles = 0;
                this.hiddenNeuronCount++;

                this.currentNetwork = new FeedforwardNetwork();
                this.currentNetwork.AddLayer(new FeedforwardLayer(
                        this.train[0].Length));
                this.currentNetwork.AddLayer(new FeedforwardLayer(
                        this.hiddenNeuronCount));
                this.currentNetwork.AddLayer(new FeedforwardLayer(
                        this.ideal[0].Length));
                this.currentNetwork.Reset();

                this.backprop = new Backpropagation(this.currentNetwork,
                        this.train, this.ideal, this.rate, this.momentum);
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Internal method that will loop through all hidden neurons and prune them
        /// if pruning the neuron does not cause too great of an increase in error.
        /// </summary>
        /// <returns>True if a prune was made, false otherwise.</returns>
        protected bool FindNeuron()
        {

            for (int i = 0; i < this.HiddenCount; i++)
            {
                FeedforwardNetwork trial = this.ClipHiddenNeuron(i);
                double e2 = DetermineError(trial);
                if (e2 < this.maxError)
                {
                    this.currentNetwork = trial;
                    return true;
                }
            }
            return false;
        }
Exemplo n.º 9
0
        /// <summary>
        /// Internal method to determine the error for a neural network.
        /// </summary>
        /// <param name="network">The neural network that we are seeking a error rate for.</param>
        /// <returns>The error for the specified neural network.</returns>
        protected double DetermineError(FeedforwardNetwork network)
        {
            return network.CalculateError(this.train, this.ideal);

        }
Exemplo n.º 10
0
 /// <summary>
 /// Constructor that is designed to setup for a selective prune.
 /// </summary>
 /// <param name="network">The neural network that we wish to prune.</param>
 /// <param name="train">The training set input data.</param>
 /// <param name="ideal">The ideal outputs for the training set input data.</param>
 /// <param name="maxError">The maximum allowed error rate.</param>
 public Prune(FeedforwardNetwork network, double[][] train,
          double[][] ideal, double maxError)
 {
     this.currentNetwork = network;
     this.train = train;
     this.ideal = ideal;
     this.maxError = maxError;
 }
Exemplo n.º 11
0
        /// <summary>
        /// Compare the two neural networks. For them to be equal they must be of the
        /// same structure, and have the same matrix values.
        /// </summary>
        /// <param name="other">The other neural network.</param>
        /// <returns>True if the two networks are equal.</returns>
        public bool Equals(FeedforwardNetwork other)
        {
            int i = 0;

            foreach (FeedforwardLayer layer in this.Layers)
            {
                FeedforwardLayer otherLayer = other.Layers[i++];

                if (layer.NeuronCount != otherLayer.NeuronCount)
                {
                    return false;
                }

                // make sure they either both have or do not have
                // a weight matrix.
                if ((layer.LayerMatrix == null) && (otherLayer.LayerMatrix != null))
                {
                    return false;
                }

                if ((layer.LayerMatrix != null) && (otherLayer.LayerMatrix == null))
                {
                    return false;
                }

                // if they both have a matrix, then compare the matrices
                if ((layer.LayerMatrix != null) && (otherLayer.LayerMatrix != null))
                {
                    if (!layer.LayerMatrix.Equals(otherLayer.LayerMatrix))
                    {
                        return false;
                    }
                }
            }

            return true;
        }
Exemplo n.º 12
0
        /// <summary>
        /// Return a clone of the structure of this neural network. 
        /// </summary>
        /// <returns>A cloned copy of the structure of the neural network.</returns>

        public FeedforwardNetwork CloneStructure()
        {
            FeedforwardNetwork result = new FeedforwardNetwork();

            foreach (FeedforwardLayer layer in this.layers)
            {
                FeedforwardLayer clonedLayer = new FeedforwardLayer(layer.NeuronCount);
                result.AddLayer(clonedLayer);
            }

            return result;
        }