Futebol de robôs: relatório final

Transcrição

1 Universidade Federal do Rio Grande do Sul Instituto de Informática Redes Neurais e Sistemas Fuzzy INF01036 Futebol de robôs: relatório final Christian Northfleet Márcio de Oliveira de Dezembro de 2010

2 1. Introdução Este relatório apresenta uma descrição das características gerais do trabalho prático desenvolvido ao longo do semestre. O objetivo do trabalho é o desenvolvimento de um robô para uma simulação de futebol de robôs. A implementação é realizada de duas maneiras, uma primeira utilizando sistemas fuzzy e uma segunda através de aprendizado por redes neurais. Serão descritas as escolhas de projeto, conjuntos e regras fuzzy, métodos e o processo de treinamento neural. 2. Robô Fuzzy Após uma primeira tentativa de implementação em Java, foi identificado um problema com a conversão de ângulos e a função GetTargetAngle. Apesar de não ter sido identificada a principal causa do problema, a função apresentava o resultado esperado nas bibliotecas C++ disponibilizadas. A partir deste fato, o robô fuzzy teve seu desenvolvimento continuado em C Estrutura e funções lógicas Para realizar as operações lógicas fuzzy, foi desenvolvida uma base de estruturas e funções. Para as estruturas, foram definidas classes que representavam diferentes conjuntos fuzzy, como: Triângulo Trapézio Gama Delta Todos os conjuntos herdam do conjunto abstrato FuzzyGroup. Isto é feito para que os conjuntos possam ser usados nas funções de inferência de forma intercambiável. A definição desta superclasse é: class fuzzygroup public: virtual float membership(float u) = 0; float centre; ; Onde membership é a função de pertinência e centre o centro do conjunto, valor usado para o método de inferência das alturas (que será discutido mais adiante). O seguinte trecho exemplifica a definição do conjunto fuzzy triangular e seu construtor: class fuzzytriangle:public fuzzygroup protected: float alpha; float beta; float gamma; public: fuzzytriangle(float alpha, float beta, float gamma); float membership(float u);

3 ; fuzzytriangle::fuzzytriangle(float alpha, float beta, float gamma) this->alpha = alpha; this->beta = beta; this->gamma = gamma; this->centre = beta; A função de pertinência é calculada a partir dos valores obtidos na criação do conjunto: float fuzzytriangle::membership(float u) float mi = 0.0; if ((u < alpha) (u > gamma)) mi = 0.0; if ((u >= alpha) && (u <= beta)) mi = (u - alpha)/(beta - alpha); if ((u > beta) && (u <= gamma)) mi = (gamma - u)/(gamma - beta); return mi; Para a inferência, foi necessário definir uma função que calcula a força de disparo (mínima) considerando 3 conjuntos como entrada: float fuzzylogic::trigger(fuzzygroup* first, float x, fuzzygroup* second, float y, fuzzygroup* third, float w) float mi[3]; mi[0] = first->membership(x); mi[1] = second->membership(y); mi[2] = third->membership(w); float result = 1.0; if (mi[0] < result) result = mi[0]; if (mi[1] < result) result = mi[1]; if (mi[2] < result) result = mi[2]; return result; E uma função de conclusão das regras, considerando a força de disparo e o conjunto de saída: float fuzzylogic::conclusion(float alpha, fuzzygroup* group, float z) if (alpha == 0.0) return 0.0; float mi = group->membership(z); float result = 1.0;

4 if (mi < result) result = mi; if (alpha < result) result = alpha; return result; Note que a primeira linha é uma avaliação curto-circuito para economizar tempo de processamento. 2.2 Entrada e conjuntos fuzzy Como entrada do sistema fuzzy, que controla as ações do robô, foram consideradas as seguintes informações: Ângulo em relação à bola Ângulo da bola em relação ao gol Distância da bola Para representar os ângulos, foram definidos os conjuntos: NB: Delta com parâmetros (-π, -π/2) NS: Triângulo com parâmetros (-π, -π/2, 0) ZE: Triângulo com parâmetros (-π/2, 0, π/2) PS: Triângulo com parâmetros (0, π/2, π) PB: Gama com parâmetros (π/2, π) E para representar a distância: CLOSE: Delta com parâmetros (25 e 75) NEAR: Trapézio com parâmetros (25, 75 e 300) FAR: Gama com parâmetros (300 e 400) Isto é traduzido na implementação como: fuzzydelta* NB = new fuzzydelta(-m_pi,-m_pi/2); fuzzytriangle* NS = new fuzzytriangle(-m_pi, -M_PI/2, 0.0); fuzzytriangle* ZE = new fuzzytriangle(-m_pi/2, 0.0, M_PI/2); fuzzytriangle* PS = new fuzzytriangle(0.0, M_PI/2, M_PI); fuzzygamma* PB = new fuzzygamma(m_pi/2, M_PI); fuzzygamma* FAR = new fuzzygamma(300.0, 400.0); fuzzytrapezium* NEAR = new fuzzytrapezium(25.0, 75.0, 300.0, 400.0); fuzzydelta* CLOSE = new fuzzydelta(25.0, 75.0); 2.3 Saída e regras A saída do sistema é o ângulo para onde o robô deve ir. Este resultado é traduzido nas forças dos motores na etapa de pós-processamento que será discutida mais

5 adiante. Com 5 x 5 x 3 conjuntos de entrada, são produzidas 75 regras. Representadas com 3 matrizes, uma para cada distância, e com o ângulo da bola na horizontal e ângulo do gol na vertical: Alguns comentários sobre as regras: Close NB NS ZE PS PB NB NB NS PS PS NS NS NB NS NS PS NS ZE NB NS ZE PS PB PS PS NS PS PS PB PB PS NS NS PS PB Near NB NS ZE PS PB NB NB NS PS PS NS NS NB NS PS PS NS ZE NB NS ZE PS PB PS PS NS NS PS PB PB PS NS NS PS PB Far NB NS ZE PS PB NB NB NS ZE PS PB NS NB NS ZE PS PB ZE NB NS ZE PS PB PS NB NS ZE PS PB PB NB NS ZE PS PB Far o O ângulo resultante é igual ao ângulo da bola. Isto significa que quando a distância até a bola for grande, o robô deve persegui-la da forma mais direta possível. Near o Quando a bola está na frente do robô e o gol está ao lado ou atrás, virar para o lado na direção contrária do ângulo do gol. Estas regras fazem com que o robô tente alcançar a bola pelos lados, protegendo o gol e evitando gols contra quando ele se encontra entre a bola e o gol adversário.

6 o Quando a bola está atrás, virar imediatamente na direção da bola, girando pelo lado onde está o gol adversário. Estas regras fazem com que o robô se vire de forma a estar pronto para conduzir a bola ao gol. Close o Quando a bola está na frente do robô a essa distância, é o momento de chutar. Quando o gol está à esquerda ou direita, virar nessa direção para atingir a bola no ângulo certo. Caso o gol esteja atrás, é hora de chutar para evitar um gol contra, ou seja, nas direções contrárias. 2.4 Inferência Primeiramente tentamos utilizar o método das alturas com uma implementação mais simples: float sum = 0.0; float pondersum = 0.0; for (int i = 0; i < 75; i++) sum += A[i]; //FAR pondersum += A[0]*NB->centre; pondersum += A[1]*NB->centre; pondersum += A[2]*NB->centre; pondersum += A[3]*NB->centre; pondersum += A[4]*NB->centre; double out = pondersum/sum; No entanto, faltava um pouco de precisão na condução das regras, então decidimos utilizar o método do centróide (método direto de Mamdani) com 73 amostras: float sum = 0.0; float pondersum = 0.0; for (int i = 0; i <= 72; i++) float z = i*(m_pi/36) - M_PI; float zout = 0.0; float C = 0.0; // FAR if ((C = fuzzylogic::conclusion(a[0], NB, z)) > zout) zout = C; if ((C = fuzzylogic::conclusion(a[1], NB, z)) > zout) zout = C; if ((C = fuzzylogic::conclusion(a[2], NB, z)) > zout) zout = C; if ((C = fuzzylogic::conclusion(a[3], NB, z)) > zout) zout = C;

7 if ((C = fuzzylogic::conclusion(a[4], NB, z)) > zout) zout = C; sum += zout; pondersum += z*zout; double out = pondersum/sum; 2.5 Pós-processamento Como a saída do sistema é um ângulo, é necessário transformá-la nas forças individuais dos motores: float leftmotor, rightmotor; leftmotor = cos( out ) - sin( out ); rightmotor = cos( out ) + sin( out ); A força máxima e mínima em cada motor é 1 e -1. No entanto, quando a força individual de cada motor é inversa e alta, isto leva o robô a produzir uma força de giro maior que 1. Considerando que existe inércia na simulação, isto pode fazer o robô girar sem controle. Para amortecer esse efeito, a força final é dividida pela metade: leftmotor *= 0.5; rightmotor *= 0.5; Apesar desta limitação, o robô é mais veloz em campo simplesmente por girar menos. 3. Robô Neural Para o robô neural, utilizamos os códigos de treinamento e backpropagation disponibilizados, assim como o exemplo de jogador que funcionava com base nos pesos gerados. Nossos esforços se concentraram nos arquivos de treinamento, parâmetros e em obter resultados semelhantes ao do robô fuzzy. 3.1 Treinamento sistemático Como primeira tentativa, geramos arquivos de treinamento de forma sistemática. Em um dos nossos melhores esforços, executamos as regras do robô fuzzy de forma a cobrir uma grande quantidade de ângulos e distâncias, capturando as forças nos motores como saída:

8 const float max_angle = M_PI; const float min_angle = -M_PI; const float max_distance = 1985; const float min_distance = 0; float distance_step = 0.0; for(balldistance = min_distance; balldistance <= max_distance; balldistance+=distance_step) for(targetangle = min_angle; targetangle <= max_angle; targetangle+=m_pi/72) for(ballangle = min_angle; ballangle <= max_angle; ballangle+=m_pi/72) (Robô fuzzy) fprintf(fp, "%f %f %f %f %f\n", balldistance, ballangle, targetangle, leftmotor, rightmotor); distance_step += 10.0; Este algoritmo gerou um arquivo de entradas. Para criar um arquivo de teste, alimentamos o algoritmo com entradas aleatórias: srand(time(null)); for(int i=0; i < 42050; i++) ballangle = (((float)rand()/(float)rand_max) * 2*M_PI) - M_PI; targetangle = (((float)rand()/(float)rand_max) * 2*M_PI) - M_PI; balldistance = ((float)rand()/(float)rand_max) * ; (Robô fuzzy) fprintf(fp, "%f %f %f %f %f\n", balldistance, ballangle, targetangle, leftmotor, rightmotor); O que gerou um arquivo de validação com entradas. Após múltiplas tentativas, nosso melhor resultado com estes arquivos foi com os seguintes parâmetros: Neurônios na camada oculta: 12 Taxa de aprendizado: 1/420500

9 Notamos que uma taxa de aprendizado igual ao inverso do número de entradas apresentava uma boa convergência. Os resultados do treinamento foram: Épocas: 7900 Melhor época: 5890 EMQ: Tempo de execução: segundos Apesar de apresentar um erro baixo, o comportamento aprendido era diferente do esperado. O robô perseguia a bola em quase todas as situações, esquecendo das regras especiais de curta distância que eram sua base. Isto pode ser devido ao fato de que o volume de casos de treinamento não era uniforme. Muitas das regras ativam este tipo de comportamento, perseguir representa uma espécie de mínimo local da função de aprendizado. 3.2 Treinamento a partir de jogos Em uma tentativa de encontrar dados mais representativos, geramos arquivos de treinamento a partir de partidas reais entre dois dos nossos robôs fuzzy. Um primeiro arquivo de treinamento foi gerado a partir de 5-10 minutos de jogo como jogador amarelo, consistindo de entradas. Um arquivo de validação semelhante (23503 entradas) foi utilizado, obtendo dados como jogador azul. Os parâmetros que mais convergiam foram: Neurônios na camada oculta: 6 Aprendizado: 1/25008 Os resultados do treinamento foram: Épocas: 2700 Melhor época: 690 EMQ: Tempo de execução: segundos A convergência foi bastante rápida e o erro mais alto, mas o robô parecia aprender melhor as regras especiais. Os dados eram mais representativos. Para aperfeiçoar o robô a partir desta descoberta, criamos um novo arquivo de treinamento, desta vez com uma hora de duração ( entradas). O arquivo de treinamento anterior (25008 entradas) serviu como validação no próximo experimento. Os melhores parâmetros foram: Neurônios na camada oculta: 12 Aprendizado: 1/ Os resultados do treinamento foram: Épocas: Melhor época: 9980 EMQ:

10 Tempo de execução: segundos Este foi nosso melhor resultado. A tabela de pesos final para os 12 neurônios da camada oculta é: w0 w1 w2 w E da camada de saída: w w w w w w w w w w w w w Conclusão Os resultados obtidos em sistemas fuzzy e redes neurais, apesar de imperfeitos, apresentam um bom desempenho e uma grande capacidade de demonstrar comportamento inteligente. Nos sistemas fuzzy, questões como a definição dos conjuntos, regras e o método de inferência foram cruciais. Com uma boa compreensão do problema, é possível definir conjuntos e regras relevantes que os resolvem de forma contínua. Já em redes neurais, questões como topologia da rede e escolha dos dados de treinamento fizeram muita diferença. Através do aprendizado, a rede é capaz de simular e aproximar soluções já conhecidas de forma eficiente.

11 5. Sugestões Algumas sugestões para semestres futuros: O simulador de jogos fica muito lento jogando pela rede, para jogar de forma eficiente é necessário estar em uma mesma máquina. No entanto, ele foi feito apenas para Windows. Alguns grupos acabaram fazendo em Linux e isto dificultou um pouco. Seria interessante deixar claro que a implementação deve ser compatível com Windows ou encontrar alguma outra maneira de evitar isso. Apesar de ser interessante observar a capacidade que uma rede neural tem de imitar o comportamento de um SIF, seria bom ter alguma outra atividade prática de implementação de algum mecanismo simples em redes neurais. Sugestões: memória associativa com modelo de Hopfield ou uma implementação de uma rede para identificar agrupamentos simples utilizando Instar.