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