function [] = treinarLikeABoss(diretorio, matrizFaixa, numSaidas, entradasValidacao,saidasValidacao,entradasTreinamento,saidasTreinamento,entradasTeste,saidasTeste,numTeste, p_numEscondidos, p_funcaoAtivacao, p_iteracoes, p_calculoErro, p_algoritmoTreinamento, p_funcaoAprendizagem, p_numMaxFalhasValidacao, p_taxaAprendizagem, atual)

rede = newff(matrizFaixa,[p_numEscondidos numSaidas],{p_funcaoAtivacao, p_funcaoAtivacao},p_algoritmoTreinamento,p_funcaoAprendizagem,p_calculoErro);
% matrizFaixa                    : indica que todas as entradas possuem valores na faixa entre 0 e 1
% [numEscondidos numSaidas]      : indica a quantidade de nodos escondidos e de saida da rede
% {'logsig','logsig'}            : indica que os nodos das camadas escondida e de saida terao funcao de ativacao sigmoide logistica
% 'traingdm','learngdm'          : indica que o treinamento vai ser feito com gradiente descendente (backpropagation)
% 'sse'                          : indica que o erro a ser utilizado vai ser SSE (soma dos erros quadraticos)

% Inicializa os pesos da rede criada (para ajuda, digite 'help init')
rede = init(rede);

%   Parametros do treinamento (para ajuda, digite 'help traingd')
rede.trainParam.epochs   = p_iteracoes;    % Maximo numero de iteracoes
rede.trainParam.lr       = p_taxaAprendizagem;  % Taxa de aprendizado
rede.trainParam.goal     = 0;      % Criterio de minimo erro de treinamento
rede.trainParam.max_fail = p_numMaxFalhasValidacao;      % Criterio de quantidade maxima de falhas na validacao
rede.trainParam.min_grad = 0;      % Criterio de gradiente minimo
rede.trainParam.show     = 10;     % Iteracoes entre exibicoes na tela (preenchendo com 'NaN', nao exibe na tela)
rede.trainParam.time     = inf;    % Tempo maximo (em segundos) para o treinamento

fprintf('\nTreinando ...\n')

conjuntoValidacao.P = entradasValidacao; % Entradas da validacao
conjuntoValidacao.T = saidasValidacao;   % Saidas desejadas da validacao

%   Treinando a rede
[redeNova,desempenho,saidasRede,erros] = train(rede,entradasTreinamento,saidasTreinamento,[],[],conjuntoValidacao);
% redeNova   : rede apos treinamento
% desempenho : apresenta os seguintes resultados
%              desempenho.perf  - vetor com os erros de treinamento de todas as iteracoes (neste exemplo, escolheu-se erro SSE)
%              desempenho.vperf - vetor com os erros de validacao de todas as iteracoes (idem)
%              desempenho.epoch - vetor com as iteracoes efetuadas
% saidasRede : matriz contendo as saidas da rede para cada padrao de treinamento
% erros      : matriz contendo os erros para cada padrao de treinamento
%             (para cada padrao: erro = saida desejada - saida da rede)
% Obs.       : Os dois argumentos de 'train' preenchidos com [] apenas sao utilizados quando se usam delays
%             (para ajuda, digitar 'help train')

fprintf('\nTestando ...\n');

%    Testando a rede
[saidasRedeTeste,Pf,Af,errosTeste,desempenhoTeste] = sim(redeNova,entradasTeste,[],[],saidasTeste);
% saidasRedeTeste : matriz contendo as saidas da rede para cada padrao de teste
% Pf,Af           : matrizes nao usadas neste exemplo (apenas quando se usam delays)
% errosTeste      : matriz contendo os erros para cada padrao de teste
%                  (para cada padrao: erro = saida desejada - saida da rede)

% desempenhoTeste : erro de teste (neste exemplo, escolheu-se erro SSE)
treinamentoDesempenho = desempenho.perf(length(desempenho.perf));
validadeDesempenho    = desempenho.vperf(length(desempenho.vperf));
testeDesempenho       = desempenhoTeste;

%     Calculando o erro de classificacao para o conjunto de teste
%     (A regra de classificacao e' winner-takes-all, ou seja, o nodo de saida que gerar o maior valor de saida
%      corresponde a classe do padrao).
%     Obs.: Esse erro so' faz sentido se o problema for de classificacao. Para problemas que nao sao de classificacao,
%           esse trecho do script deve ser eliminado.

[maiorSaidaRede, nodoVencedorRede] = max (saidasRedeTeste);
[maiorSaidaDesejada, nodoVencedorDesejado] = max (saidasTeste);

%      Obs.: O comando 'max' aplicado a uma matriz gera dois vetores: um contendo os maiores elementos de cada coluna
%            e outro contendo as linhas onde ocorreram os maiores elementos de cada coluna.

classificacoesErradas = 0;

% matriz confunsao
c1c1 = 0;
c1c2 = 0;
c2c1 = 0;
c2c2 = 0;

c1 = 0;
c2 = 0;

T = [];

for padrao = 1 : numTeste;
    if nodoVencedorRede(padrao) ~= nodoVencedorDesejado(padrao),
        classificacoesErradas = classificacoesErradas + 1;
    end
    
    if nodoVencedorDesejado(padrao) == 1
        c1 = c1 + 1;
        T(padrao, 1) = 1;
        if nodoVencedorRede(padrao) == 1
            c1c1 = c1c1 +1;
        else
            c1c2 = c1c2 + 1;
        end

    else
        c2 = c2 +1;
        T(padrao, 1) = 0;
        if nodoVencedorRede(padrao) == 1
            c2c1 = c2c1 + 1;
        else
            c2c2 = c2c2 + 1;
        end
    end
    T(padrao, 2) = saidasRedeTeste(1, padrao);
end

erroClassifTeste = 100 * (classificacoesErradas/numTeste);

[TP, FP] = roc_ruan(T(:, 1), T(:, 2));
plot(FP, TP);
xlabel('False Positive rate');
ylabel('True Positive rate');
title('ROC Curve');
auc = auroc(TP, FP);

saveas(gcf, strcat('H:\public_html\redes\replicando\fotos', atual, '.png'));

%   abrindo arquivos de resposta

arquivoRespostaTexto  = fopen(strcat(diretorio,'RespostaTexto.txt'),'a+');
arquivoRespostaMatriz = fopen(strcat(diretorio,'RespostaMatriz.txt'),'a+');

%   print no arquivo de resultados texto

fprintf(arquivoRespostaTexto, 'Configuracao atual: %s \n', atual);
fprintf(arquivoRespostaTexto, 'Numeros de Nos na camada intermediaria: %i \n', p_numEscondidos);
fprintf(arquivoRespostaTexto, 'Numero maximo de iteracoes: %i \n', rede.trainParam.epochs);
fprintf(arquivoRespostaTexto, 'Taxa de aprendizado: %f \n', rede.trainParam.lr);
fprintf(arquivoRespostaTexto, 'Algoritmo de Treinamento: %s \n', p_algoritmoTreinamento);
fprintf(arquivoRespostaTexto, 'Funcao de Aprendizagem: %s \n', p_funcaoAprendizagem);
fprintf(arquivoRespostaTexto, 'Funcao Ativacao: %s \n', p_funcaoAtivacao);
fprintf(arquivoRespostaTexto, 'Quantidade Maxima de Falhas na Validacao: %i \n', p_numMaxFalhasValidacao);
fprintf(arquivoRespostaTexto, 'Quantidade de Classificacoes Erradas: %i \n', classificacoesErradas);
fprintf(arquivoRespostaTexto, 'Numero de interações efetuadas: %i \n', length(desempenho.epoch)-1);
fprintf(arquivoRespostaTexto, '%s para o conjunto de treinamento: %6.5f \n',p_calculoErro,treinamentoDesempenho);
fprintf(arquivoRespostaTexto, '%s para o conjunto de validacao: %6.5f \n',p_calculoErro,validadeDesempenho);
fprintf(arquivoRespostaTexto, '%s para o conjunto de teste: %6.5f \n',p_calculoErro,testeDesempenho);
fprintf(arquivoRespostaTexto, 'Erro de classificacao para o conjunto de teste: %6.5f\n',erroClassifTeste);
fprintf(arquivoRespostaTexto, '\nCURVA ROC: \nArea abaixo da curva = %2.3f\n',auc);
fprintf(arquivoRespostaTexto,'\nMATRIZ DE CONFUSAO\n');
fprintf(arquivoRespostaTexto,'     C1        C2\n');
fprintf(arquivoRespostaTexto,'C1 :%1.2f      %1.2f\n',c1c1/c1,c1c2/c1);
fprintf(arquivoRespostaTexto,'C2 :%1.2f      %1.2f\n\n',c2c1/c2,c2c2/c2);
fprintf(arquivoRespostaTexto, '\n---------------------------------------------------------\n\n');

%   print no arquivo de resultados matriz

% fprintf(conf_atual, arquivoRespostaMatriz, 'NumeroEscondido,Iteracoes,TaxaAprend,AlgTren,FunApre,FunAtiv,QuantFalha,QuantClasErro,NumItera,Treinamento,Validacao,Teste,ErroClas;AreaCurvaROC\n');
fprintf(arquivoRespostaMatriz, '%s,%i,%i,%f,%s,%s,%s,%i,%i,%i,%6.5f,%6.5f,%6.5f,%6.5f,%2.3f,%1.2f,%1.2f\n',atual,p_numEscondidos, rede.trainParam.epochs,rede.trainParam.lr,p_algoritmoTreinamento,p_funcaoAprendizagem,p_funcaoAtivacao,p_numMaxFalhasValidacao,classificacoesErradas,length(desempenho.epoch)-1 , treinamentoDesempenho,validadeDesempenho, testeDesempenho,erroClassifTeste, auc, c1c1/c1, c2c2/c2);

fclose(arquivoRespostaTexto);
fclose(arquivoRespostaMatriz);

%    print no console
fprintf('Configuracao atual: %s \n', atual);
fprintf('Numeros de Nos na camada intermediaria: %i \n', p_numEscondidos);
fprintf('Numero maximo de iteracoes: %i \n', rede.trainParam.epochs);
fprintf('Taxa de aprendizado: %f \n', rede.trainParam.lr);
fprintf('Algoritmo de Treinamento: %s \n', p_algoritmoTreinamento);
fprintf('Funcao de Aprendizagem: %s \n', p_funcaoAprendizagem);
fprintf('Funcao Ativacao: %s \n', p_funcaoAtivacao);
fprintf('Quantidade Maxima de Falhas na Validacao: %i \n', p_numMaxFalhasValidacao);
fprintf('Numero de interações efetuadas: %i \n', length(desempenho.epoch)-1);
fprintf('Quantidade de Classificacoes Erradas: %i \n', classificacoesErradas);
fprintf('%s para o conjunto de treinamento: %6.5f \n',p_calculoErro,treinamentoDesempenho);
fprintf('%s para o conjunto de validacao: %6.5f \n',p_calculoErro,validadeDesempenho);
fprintf('%s para o conjunto de teste: %6.5f \n',p_calculoErro,testeDesempenho);
fprintf('Erro de classificacao para o conjunto de teste: %6.5f\n',erroClassifTeste);
fprintf('\nCURVA ROC: \nArea abaixo da curva = %2.3f\n',auc);
fprintf('\nMATRIZ DE CONFUSAO\n');
fprintf('     C1        C2\n');
fprintf('C1 :%1.2f      %1.2f\n',c1c1/c1,c1c2/c1);
fprintf('C2 :%1.2f      %1.2f\n\n',c2c1/c2,c2c2/c2);
fprintf('\n---------------------------------------------------------\n\n');