/// <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); }
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()); }