예제 #1
0
        public TrainPair getPair()
        {
            TrainPair aux = data[data.Count - 1];

            data.Remove(aux);
            return(aux);
        }
예제 #2
0
        private double error(TrainPair tp, double[] salida)
        {
            double aux = 0;

            for (int i = 0; i < n_output; i++)
            {
                aux += Math.Pow(tp.getOutputs()[i] - salida[i], 2);
            }
            return(aux / 2);
        }
예제 #3
0
        public void train(TrainSet ts, double learning_rate)
        {
            double[,] aux_partial = new double[n_output, n_interior];
            double[] salida = new double[n_output];
            Tuple <double[], double[]> aux;

            double[] hidden = new double[n_interior];
            double   total_error = 0, updated_weight;

            while (!ts.finish())
            {
                TrainPair tp = ts.getPair();

                aux    = forward(tp.getInputs());
                hidden = aux.Item1;
                salida = aux.Item2;

                total_error = error(tp, salida);

                //Console.WriteLine("Current Network Error: {0}", total_error);

                // Train output
                for (int i = 0; i < n_output; i++)
                {
                    for (int j = 0; j < n_interior; j++)
                    {
                        aux_partial[i, j] = -(tp.getOutputs()[i] - salida[i]) * derivada(salida[i]) * hidden[j];
                        updated_weight    = output[i].getWeights()[j] - learning_rate * aux_partial[i, j];
                        output[i].updateWeight(j, updated_weight);
                    }
                }
                aux_partial = new double[n_interior, n_input];
                // Train hidden
                for (int i = 0; i < n_interior; i++)
                {
                    for (int j = 0; j < n_input; j++)
                    {
                        double deltasum = 0;

                        for (int k = 0; k < n_output; k++)
                        {
                            deltasum += output[k].getWeights()[i] * (-(tp.getOutputs()[k] - salida[k]) * derivada(salida[k]));
                        }

                        aux_partial[i, j] = deltasum * derivada(hidden[i]) * input[j];

                        updated_weight = interior[i].getWeights()[j] - learning_rate * aux_partial[i, j];

                        interior[i].updateWeight(j, updated_weight);
                    }
                }
            }
            Console.WriteLine("Net Error: " + total_error);
        }