Estou elaborando um trabalho com redes neurais,
o problema, eu acho, é que tenho várias váriaveis possiveis…
Não sei se é o melhor algoritmo de IA mas é assim…
Tenho um jogo de futebol e quero usar redes neurais para
determinar as ações dos jogadores…
Fiz o seguinte, como entrada defini vários ENUMS com valores
sequenciais 0.1, 0.2, 0.3 representando por exemplo, habilidade,
posição, estado, etc… e como saida teria varias ações que o jogador
poderia executar, tabém 0.1, 0.2, 0.3, 0.4, etc…
Em um primeiro teste hávia funcionado, mas do nada
começou a dar uns valores absurdos… por exemplo:
Eu treinei para 0.1 e 0.1 (2 entradas) ter como saida (0.35)
mas as vezes sai 0.36989795 o que considero correto, mas
as vezes sai 5.158140149663072E-6 totalmente sem sentido,
sendo que informei como entrada o mesmo que foi treinado (0.1 e 0.1)
Minha dúvida, posso usar valores muito baixos como entrada
e saida prevista ? ao invés de 0.1 usar 0.001 …
Percebi também que se treino d+ os resultados começam a ficar muito errado
como o exemplo acima do 5.158140149663072E-6
Acho que “descobri” o problema,
estou lendo o livro “Introduction to Neural Networks for Java”
e lá no exemplo do “XOR” ele usava 5000 iterações de treino
para um exemplo simples de 0.0 e 0.1
Por algum motivo que não consegui descobrir ainda,
utilizando valores de ponto flutuante maiores, tenho que
treinar a rede muito mais, de 5000 tive que colocar 100000
para obter os resultados desejados…
Agora a duvida, como quero algo dinâmico,
é aconselhavel ao invés de iterar sobre um numero
fixo de épocas, eu treinar até a taxa de erros ser menor
que um determinado valor desejado como por exemplo 0.001 ?
Sem descrever seu protocolo, fica difícil te ajudar:
a) De onde veio a base?
b) Usou alguma base de testes? Sua base de resultados é diferente da base de treinamento?
Cuidado com essa história de treinar até uma determinada margem de erro.
Muitas vezes você acaba especializando demais sua rede, o que torna ela viciada na sua base de treinamento.
Procure um algorítmos que façam treinamento com uso de bases de testes para obter generalização máxima.
O backpropagation requer que você normalize sua entrada. Não se pode trabalhar com valores flutuantes como input, senão seu treino pode nunca convergir. Treinar redes neurais é uma “arte” como dizem alguns especialistas.
[quote=ViniGodoy]Sem descrever seu protocolo, fica difícil te ajudar:
a) De onde veio a base?
b) Usou alguma base de testes? Sua base de resultados é diferente da base de treinamento?
Cuidado com essa história de treinar até uma determinada margem de erro.
Muitas vezes você acaba especializando demais sua rede, o que torna ela viciada na sua base de treinamento.
Procure um algorítmos que façam treinamento com uso de bases de testes para obter generalização máxima.
[/quote]
Opa, desculpem a demora, deu uns problemas aqui em santa-catarina
e não vi mais o fórum.
Então, a base que você diz é a entrada e a saida esperada ? Esta eu estou montando com um CSV, mais
ou menos assim:
Ali tem um header que é descartado,só para identificação, a classe (enum)
onde estão os valores de cada linha, e abaixo os valores que eu por reflexão.
As classes estão assim (uma parte delas):
Dai com bases nesses valores, e no CSV que vou montando aos poucos,
eu mando ele treinar usando FeedForward com Backpropagation.
//Carrega o arquivo csv
final DataLoader data = new DataLoader();
data.loadDatabase("resources/neural_database.csv");
//Recupera os dados do arquivo csv
final double[][] input = data.getInput();
final double[][] output = data.getOutput();
//Define os camadas de entrada e saida
motor.setCamadaEntrada(4);
motor.addCamadaOculta(2);
motor.setCamadaSaida(1);
//Define os dados de entrada e saida
motor.setEntradaEsperada(input);
motor.setSaidaEsperada(output);
//Define as taxas
motor.setTaxaAprendizagem(0.7);
motor.setMomento(0.1);
motor.setTreinoMinimo(2000000);
motor.setTaxaErroMinima(0.001);
//Executa o motor
ThreadUtils.runThreadAndWait(motor);
O que não sei se é assim, as taxas de erro estão muito altas, o que
leva as uns valores muito fora. Cada vez que eu mando ele treinar
muda bastante as taxas de erro, algumas vezes ele treina rápido,
outras leva muito tempo e não fica com um valor aceitavel.
[quote=juliocbq]O backpropagation requer que você normalize sua entrada. Não se pode trabalhar com valores flutuantes como input, senão seu treino pode nunca convergir. Treinar redes neurais é uma “arte” como dizem alguns especialistas.
E desse jeito como vc pretende medir a qualidade da sua rede? Você não pode inferir qualquer coisa se você não tiver uma base de dados confiável.[/quote]
Não entendi direito, eu que estou definindo os valores,
é tipo uma simulação de futebol, eu tenho meus jogadores
em campo jogando, com base nas váriaveis do jogo e dos jogadores
eu pretendo decidir a ação do goleiro.
Assim sendo, quando chega o momento de executar a ação do goleiro eu chamo a rotina da rede neural
passando o tipo do jogador, no caso ali só tem o goleiro (eu atribui um valor para
esse tipo de jogador, no caso ali (0.1);
passo também o status dele, no caso ali (LIVRE) contabilizando a quantidade de jogadores perto dele eu defino qual é;
passo também a posição dele em campo (dividi o campo em várias áreas quadradas, totalizando 16)
passo a posição da bola em jogo, assim como a posição do jogador
e por final a ação/resultado esperada, que é o valor que ele vai me retornar. Com base
no retorno, eu verifico quais das habilidade treinadas eu vou executar, por exemplo:
Se ele me retorna 0.001 ou algo próximo disto eu não faço nada (NAO_MOVER),
se ele retornar 0.117 eu executo a ação MOVER_ESQUERDA (0.120).
Ou será que o que estou tantando fazer não é possivel ? Seria um problema
Quanto a normalizar as entradas, eu só achei sobre isso
no “Self-Organizing Map” no Backpropagation que eu li,
os valores devem estar entra 0 e 1.[/quote]
Hitcurst, O modelo kohonen é usado para resolver problemas de agrupamento e reconhecimento de padrões. Para você ter uma idéia, um ocr usa uma rede kohonen para reconhecer caracteres. Back propagation
é o método de treino. Normalmente backpropagation é utilizada em redes com perceptrons.
Se o modelo da rede não encaixa no modelo do problema, o treino não converge.
Você está tentando resolver um problema com a ferramenta errada. Precisa rever o problema e buscar a ferramenta matemática certa para a solução do mesmo.
Dá uma lida na documentação da aforge.net. É uma biblioteca c# opensource, e implementa a maioria dos algoritmos de treino e a maioria dos modelos de redes. Possui um monte de exemplos solucionando vários tipos de problemas.
