Beispiel #1
0
        /// <summary>
        /// Faz a previsão de pontos inéditos a rede neural treinada.
        /// </summary>
        /// <param name="dadosBase">Dados a serem comparados com os previstos.</param>
        /// <param name="dadosAuxiliares">Dados prévios aos dados base. Para Validação: dados de treinamento. Para Teste: dados de validação.</param>
        /// <param name="indiceID">Indice em que se inicia os dados base em relação aos dados totais. Para validação: tamanho dos dados de treinamento. Para teste: tamanho dos dados de treinamento somado ao tamanho dos de teste.</param>
        /// <returns></returns>
        private List <double> Prever(List <double> dadosBase, List <double> dadosAuxiliares, int indiceID)
        {
            network = (ActivationNetwork)ActivationNetwork.Load(@"C:\Users\Paulo\Desktop\NetworkTest.bin");

            //criação da lista de dados provisória usada na previsão
            List <double> dadosPrevisao = new List <double>();

            List <double> diferenca = new List <double>();

            //lista contendo todos os ids de 1 a 52
            List <int> ids = Serie.Ids;

            //variavel que possuirá o id binário
            int[] id = new int[6];

            int tamanhoAux = (dadosAuxiliares.Count);

            //inicio do processo de adição de dados à lista fazendo que
            //o primeiro ponto previsto seja exatamente o ultimo dos dados auxiliares
            int con = (dadosAuxiliares.Count) - windowSize - 1;

            for (int i = con; i < tamanhoAux; i++)
            {
                //adiciona os valosres de data, a lista de dados para treino primeiro
                dadosPrevisao.Add(dadosAuxiliares[i]);
            }

            //definição do tamanho da solução, deve ser do tamanho do teste mais um
            int           solutionSize = dadosBase.Count + 1;
            List <double> solution     = new List <double>();

            //definição do tamanho da entrada da rede neural para a previsão
            double[] networkInput = new double[windowSize + predictionSize * 6];

            //variavel auxiliar para o id binário
            int contador = 0;

            con = indiceID - windowSize - 1;

            //inicia processo de predição deslocando de um por um os pontos previstos
            for (int i = 0, n = dadosBase.Count + 1; i < n; i = i + predictionSize)
            {
                int a = windowSize;
                contador = 0;
                // seta os valores da atual janela de previsão como entrada da rede neural
                for (int j = 0; j < windowSize + predictionSize; j++)
                {
                    if (j < windowSize)
                    {
                        //entrada tem de ser formatada
                        networkInput[j] = (dadosPrevisao[i + j] - Serie.Min) * fatorNormal - 1.0;
                    }
                    else
                    {
                        id = CUtil.ConversaoBinario(ids[con + i + a]);
                        a++;

                        for (int c = 0; c < 6; c++)
                        {
                            networkInput[windowSize + contador] = id[c];
                            contador++;
                        }
                    }
                }//fim do for interno

                for (int k = 0; k < network.Compute(networkInput).Length; k++)
                {
                    if ((i + k) < solutionSize)
                    {
                        diferenca.Add((network.Compute(networkInput)[k] + 1.0) / fatorNormal + Serie.Min);
                        dadosPrevisao.Add((network.Compute(networkInput)[k] + 1.0) / fatorNormal + Serie.Min);
                    }
                }
            }//fim do for externo

            solution = Serie.DiferencaInversa(diferenca, Serie.Dados[indiceID, 1]);
            solution.RemoveAt(0);

            return(solution);
        }
Beispiel #2
0
        public List <double> Treino(string path)
        {
            double learningUtheil = 0.0;
            double learningError  = 0.0;

            double validationError  = 0.0;
            double validationUtheil = 0.0;
            double validationMAPE   = 0.0;

            //setando o erro de comparação da validação em um valor extremo
            menoresErros[2] = 1000;

            //variável que conta a quantidade de iterações
            int iteration;

            //variável auxiliar que define quando o processo de treino acaba
            bool needToStop = false;

            //fator de normalização
            fatorNormal = 2.0 / (Serie.Max - Serie.Min);

            //lista contendo todos os ids de 1 a 52
            List <int> ids = Serie.Ids;

            //variavel que possuirá o id binário
            int[] id = new int[6];

            // número de amostras para a aprendizagem
            int samples = dadosTreino.Count - windowSize - predictionSize;

            // preparação dos dados para a aprendizagem
            double[][] input  = new double[samples][]; //vetor de entrada
            double[][] output = new double[samples][]; //vetor de saída

            for (int i = 0; i < samples; i++)
            {
                //define o tamanho da entrada
                input[i] = new double[windowSize + predictionSize * 6];
                //define o tamanho da saída
                output[i] = new double[predictionSize];

                // configura a entrada com os dados formatados
                for (int j = 0; j < windowSize + predictionSize * 6; j++)
                {
                    if (j < windowSize)
                    {
                        input[i][j] = (dadosTreino[i + j] - Serie.Min) * fatorNormal - 1.0;
                    }
                    else
                    {
                        if (j == windowSize)
                        {
                            id = CUtil.ConversaoBinario(ids[i + windowSize]);
                        }

                        input[i][j] = id[j - windowSize];
                    }
                }// fim do for interno

                // configura os dados de saída com os dados transformados
                for (int k = 0; k < predictionSize; k++)
                {
                    output[i][k] = (dadosTreino[i + k + windowSize] - Serie.Min) * fatorNormal - 1;
                }
            }//fim do for externo

            //cria o "Professor" da rede neural
            ParallelResilientBackpropagationLearning teacher = new ParallelResilientBackpropagationLearning(network);

            //Variável para contar o número de iterações
            iteration = 1;

            //vetor que armazena a solução encontrada pela rede neural
            int solutionSize = dadosTreino.Count - windowSize;

            double[] solution = new double[solutionSize];

            //Vetor auxiliar que seta as entrada a serem computadas pela rede neural
            double[] networkInput = new double[windowSize + predictionSize * 6];

            // loop que efetua as iterações
            while (!needToStop)
            {
                learningError  = 0.0;
                learningUtheil = 0.0;

                //roda uma iteração do processo de aprendizagem retornando o erro obtido
                double error = teacher.RunEpoch(input, output) / samples;

                //variaveis auxiliares para calculo do utheil
                double somaY = 0.0;
                double somaF = 0.0;

                //variavel auxiliar para calcular os erros
                int amostra = 0;

                //variavel auxiliar para o id binário
                int contador = 0;

                // computa as saídas através de toda a lista de dados, armazena os valores de saída da rede em solution
                for (int i = 0, n = dadosTreino.Count - windowSize - predictionSize + 1; i < n; i++)
                {
                    int a = windowSize;
                    contador = 0;
                    // seta os valores da atual janela de previsão como entrada da rede neural
                    for (int j = 0; j < windowSize + predictionSize; j++)
                    {
                        if (j < windowSize)
                        {
                            //entrada tem de ser formatada
                            networkInput[j] = (dadosTreino[i + j] - Serie.Min) * fatorNormal - 1.0;
                        }
                        else
                        {
                            id = CUtil.ConversaoBinario(ids[i + a]);
                            a++;

                            for (int c = 0; c < 6; c++)
                            {
                                networkInput[windowSize + contador] = id[c];
                                contador++;
                            }
                        } //fim do else
                    }     //fim do for interno

                    //computa a saída da rede e armazena o dado solution diferenca
                    for (int k = 0; k < network.Compute(networkInput).Length; k++)
                    {
                        double diferenca = (network.Compute(networkInput)[k] + 1.0) / fatorNormal + Serie.Min;
                        if ((i + k) < solutionSize)
                        {
                            solution[i + k] = (diferenca) + Serie.Dados[windowSize + i, 1];
                        }
                    }

                    //calcula o erro de aprendizagem
                    amostra++;

                    //variaveis auxiliares do u theil
                    somaY += ((Serie.Dados[windowSize + i, 1]) * (Serie.Dados[windowSize + i, 1]));
                    somaF += ((solution[i] * solution[i]));

                    learningError += ((solution[i] - Serie.Dados[windowSize + i + 1, 1]) * (solution[i] - Serie.Dados[windowSize + i, 1]));
                }//fim do for externo

                learningError = (learningError) / amostra;
                somaF         = somaF / amostra;
                somaY         = somaY / amostra;

                learningUtheil = Math.Sqrt(learningError) / (Math.Sqrt(somaY) + Math.Sqrt(somaF));

                // validação
                if (iteration >= 30)
                {
                    Validacao();
                }

                // incrementa a iteração atual
                iteration++;

                // confere se precisamos ou não parar, fator de parada é o número de iterações
                if (iteration > 400)
                {
                    break;
                }
            }//fim do while

            validationError  = menoresErros[0];
            validationMAPE   = menoresErros[1];
            validationUtheil = menoresErros[2];

            return(solution.ToList());
        }