Redes Neurais - Backpropagation

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.

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:

TIPO_JOGADOR;          STATUS_JOGADOR;        QUADRANTE_JOGADOR;        QUADRANTE_BOLA;        RESULTADO_1
PosicaoJogador.class;   StatusJogador.class;   PosicaoCampo.class;       PosicaoCampo.class;    HabilidadeJogador.class
;;;;
GOLEIRO;                 LIVRE;                    QUADRANTE_02;            QUADRANTE_01;            NAO_MOVER
GOLEIRO;                 LIVRE;                    QUADRANTE_03;            QUADRANTE_04;            NAO_MOVER
GOLEIRO;                 LIVRE;                    QUADRANTE_03;            QUADRANTE_01;            MOVER_ESQUERDA
GOLEIRO;                 LIVRE;                    QUADRANTE_02;            QUADRANTE_04;            MOVER_DIREITA

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):

public enum PosicaoJogador {

	GOLEIRO	(0.1),
	ZAGUEIRO (0.2),
	LATERAL	(0.3),
	MEIOCAMPO (0.4),
	ATACANTE (0.5);

public enum StatusJogador {

	LIVRE (0.1),
	MARCADO_LEVE (0.2),
	MARCADO_NORMAL (0.3),
	MARCADO_PESADO (0.4);

public enum PosicaoCampo {

	QUADRANTE_01 (0.1),
	QUADRANTE_02 (0.2),
	QUADRANTE_03 (0.3),
	QUADRANTE_04 (0.4),
        .....
	QUADRANTE_15 (0.15),
	QUADRANTE_16 (0.16);

Nessa classe abaixo eu botei os valores mais distantes,
para a margem de erro nao pegar alguma habilidade totalmente
diferente.

public enum HabilidadeJogador  {

	NAO_MOVER		       (0.001),

	MOVER_CIMA 		        (0.101),
	MOVER_CIMA_ESQUERDA 	(0.102),
	MOVER_CIMA_DIREITA	(0.103),

	MOVER_BAIXO 		        (0.110),
	MOVER_BAIXO_ESQUERDA	(0.111),
	MOVER_BAIXO_DIREITA	(0.112),

	MOVER_ESQUERDA		(0.120),
	MOVER_DIREITA 		(0.130);

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.

http://qnetv2k.com/Qnet2000Manual/html/qnet6sku.htm

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.

Ok, mas vc tirou esses dados de onde? Da sua cabeça?

Sim

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.

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.

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

hitcurst:

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.

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.

http://www.aforgenet.com/framework/features/