Evitar Obstáculos usando Inteligência Artificial

Ferramentas e máquinas necessárias

	Ferro de soldar (genérico)
	Arame de solda, sem chumbo
	Fluxo de solda, solda
	Bomba de dessoldagem, Deluxe SOLDAPULLT®
	Decapador e cortador de fio, 18-10 AWG / 0,75-4 mm² Fios de capacidade
	Pistola de cola quente (genérica)
	Fita dupla face

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

OBSTÁCULO EVITANDO ROBÔ USANDO IA / APRENDIZAGEM DE REFORÇO

Como o L298N aciona dois motores CC:

Como o sensor HC-SR04 calcula a distância:

Termos importantes na aprendizagem por reforço:

  int ACTIONS =[0,1,2,3] 
 
 / * AQUI:
 0 =PARA A FRENTE 
 1 =PARA TRÁS 
 2 =PARAR 
 3 =DIREITO * /  

  / * APÓS REALIZAR UMA AÇÃO, O ROBÔ VAI PARA O PRÓXIMO ESTADO NESTE CASO DE OBSTÁCULO 
 EVITANDO O ROBÔ * / 
 
 int NEXT_STATE; 
 int STATE =0; 
 NEXT_STATE =STATE + 1;  

  float Q [N_STATES] [NUMBER_OF_ACTIONS] ={{0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0 , 0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0}, 
 {0.0,0.0,0.0,0.0 }};  

  int RECOMPENSAS [ESTADOS] [NUMBER_OF_ACTIONS] ={{-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}, 
 {-10, -2, -1,10}};  

Hiperparâmetros na aprendizagem por reforço:

  float ALPHA =0.2;  

  float GAMMA =0.9;  

  float EPSILON =0.75;  

• Inicialize a tabela de valores Q, Q (s, a) . Inicializei esses valores para 0,0.
• Observe o estado atual, s .
• Escolha uma ação, a , para aquele estado com base em uma das políticas de seleção de ação explicadas aqui na página anterior (📷-soft, 📷-greedy ou softmax).

  ////////////////////////// Epsilon Greedy Policy ///////////////// /////////////// 
 
 PROB =RANDOM (EPSILON); 
 if (PROB <=EPSILON) // EXPLORE AS AÇÕES 
 {
 ACTION =random (0,4); 
 FLAG =2; 
} 
 else // EXPLORAR AS AÇÕES DA TABELA Q 
 {
 AÇÃO =ARGMAX (Q, ESTADO); 
 SINALIZADOR =2; 
}  

• Execute a ação e observe a recompensa, r , bem como o novo estado, s ' .
• Atualize o valor Q para o estado usando a recompensa observada e a recompensa máxima possível para o próximo estado. A atualização é feita de acordo com a fórmula e os parâmetros descritos acima.
• Defina o estado para o novo estado e repita o processo até que um estado terminal seja alcançado.
• Para entender o Q-learning melhor visitar este link:https://towardsdatascience.com/a-beginners-guide-to-q-learning-c3e2a30a653c

  /////////////////// Implementação da Fórmula Q_Learning /////////////////////// //// 
 
 Q_OLD =Q_TABLE [S] [A]; 
 Q_MAX =MAX (Q_TABLE, NEXT_S); 
 Q_NEW =(1-LEARNING_RATE) * Q_OLD + LEARNING_RATE * (R + DISCOUNT_FACTOR * Q_MAX); 
 Serial.print ("Q VALUE:"); 
 Serial.println (Q_NEW); 
 Q_TABLE [S] [A] =Q_NEW;  

Vídeo de trabalho:não se esqueça de verificar o vídeo de trabalho do AI Robot :)

Código

• Robô para evitar obstáculos usando Q-LEARNING

Robô para evitar obstáculos usando Q-LEARNING C / C ++

 / * Este é um robô que evita obstáculo usando aprendizado por reforço / IA Autor deste projeto:Varun Walimbe Algoritmo usado neste projeto:Q learningComo funciona como evitar obstáculos? 1.Ultrassônico o sensor é usado para medir a distância do obstáculo usando seus Pinos de Eco e Trig.2. Quando a distância é medida e se for menor que 20 cm, então há um obstáculo próximo, caso contrário, o robô está seguro e continue em frente. virar à esquerda ou à direita dependendo da situação. Como funciona a prevenção de obstáculos baseada em IA? (aprendizagem Q) 1.Aqui a 1ª etapa do artigo superior permanece a mesma. No entanto, a 2ª etapa é diferente. 2. Uma lista de ações do robô são inicializado primeiro. Por exemplo, neste caso, as ações do robô são:Esquerda, Avançar, Recuar, Parar.3. Quando o robô se aproxima de um obstáculo, é necessário executar uma ação. No entanto, observe que, neste caso, o Robô não sabe qual ação tomar, pois não está pré-programado e vai aprender por conta própria para evitar obstáculos.4. Quando o Robô para quando há um obstáculo à sua frente, ele recebe a recompensa 0 Quando o Robô para e vai para trás, ele recebe uma recompensa de -5 Quando o Robô continua a se mover para frente ignorando os obstáculos, ele recebe uma recompensa de -10 Quando o Robô se move para a esquerda assim que o obstáculo é detectado, ele recebe uma recompensa de + 105. Desta forma, o Robô aprende por conta própria como evitar obstáculos pelo mecanismo de recompensa. * /////////// PARÂMETROS DE HARDWARE DO ROBÔ ////////////////////// int TRIG_PIN =7; int ECHO_PIN =8; duração int; distância de flutuação; int M1 =13; int M2 =12; int M3 =11; int M4 =10; bool Obstáculo =falso; int FLAG; ////////// ///////////////FIM////////////////////////////////// ////////////////////////////////////// Q LEARNING PARAMETERS ///////////////// //////////////////////////////// float ALPHA =0.1; // TAXA DE APRENDIZAGEMfloat GAMMA =0.5; // FATOR DE DESCONTOfloat EPSILON =0.90; // PARÂMETRO DE EXPLORAÇÃOint REWARD; // RECOMPENSA POR REALIZAR UMA AÇÃOint EPISODES =100; int STATE; // ESTADO ATUAL DO ROBOTint AÇÃO =0; // AÇÃO REALIZADA PELO ROBÔ (0:PARA A FRENTE, 1:PARA TRÁS, 2; PARADA, 3:PARA A ESQUERDA) float PROB; // USADO PARA EPSILON DECAY bool ACTION_TAKEN =false; // ESTA VARIÁVEL NOS DIZ SE UMA AÇÃO É TOMADA OU NÃO int NEXT_STATE; // PRÓXIMO ESTADO DO ROBÔconst int STATES =10; // NÚMERO DE ESTADOS NO AMBIENTE int ACTIONS [4] ={1,2,3,4}; const int NUMBER_OF_ACTIONS =4; // TOTAL TEMOS 4 AÇÕES PARA FRENTE, PARA TRÁS, ESQUERDA E PARADA / * ESTA É A MATRIZ Q OU TABELA Q. ESTE É BASICAMENTE O DIÁRIO QUE O ROBÔ OLHARÁ ANTES DE REALIZAR UMA AÇÃO. COM BASE NA AÇÃO, O ROBÔ GANHARÁ RECOMPENSA E O VALOR Q SERÁ ATUALIZADO NESTA TABELA Q. AQUI EU CONISTEI 10 ESTADOS. ACEI QUE TODOS OS ESTADOS SÃO DIFERENTES MESMO QUE SÃO OS MESMOS.BASICAMENTE OBSTÁCULO, EVITAR O ROBÔ CONTÉM APENAS DUAS ESTADOS, isto é:1:QUANDO ESTÁ LONGE DO OBSTÁCULO 2:QUANDO ESTÁ PRÓXIMO DO OBSTÁCULO, MAS AQUI ESTÃO ACESSÓRIOS PARA ILUSTRAR MAIS COMPLEXO 10 ESTADOS DIFERENTES AQUI ESPERANDO A MESMA / AÇÃO DIFERENTE. * / Float Q [STATES] [NUMBER_OF_ACTIONS] ={{0.0,0.0,0.0,0.0}, // O MAIS IMPORTANTE DE TODOS É A TABELA Q. {0.0,0.0,0.0,0.0}, // É FORMADO PELOS ESTADOS COMO SUAS LINHAS {0.0,0.0,0.0,0.0}, // E COLUNAS COMO SEU NÚMERO DE AÇÕES {0.0,0.0,0.0,0.0}, / / INICIALIZADO PARA ZERAR NO INÍCIO {0.0,0.0,0.0,0.0}, // ISTO SERÁ ATUALIZADO NO FUTURO. {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}, {0.0,0.0,0.0,0.0}}; / * ESTA É UMA MATRIZ OU TABELA DE RECOMPENSAS. ISTO É RESPONSÁVEL POR DAR RECOMPENSA AO ROBÔ PARA REALIZAR AÇÃO PARTICULAR. ARMAZENA A RECOMPENSA POR CADA AÇÃO TOMADA NO ESTADO. A RECOMPENSA SERÁ POSITIVA SE A AÇÃO REALIZADA FOR BOA E NEGATIVA SE A AÇÃO DAR RESULTADOS RUINS. * / Int RECOMPENSAS [STATES] [NUMBER_OF_ACTIONS] ={{-10, -2, -1,10}, {-10, -2 , -1,10}, {-10, -2, -1,10}, {-10, -2, -1,10}, {-10, -2, -1,10}, {-10, -2, -1,10}, {-10, -2, -1,10}, {-10, -2, -1,10}, {-10, -2, -1,10}, {- 10, -2, -1,10}}; ////////////////////////////////////////////FIM///// //////////////////////////////////////////////////////// //////////// Q LEARNING UPDATE PARAMETERS //////////// float Q_OLD; float Q_NEW; float Q_MAX; /////////////// ///////////// END ////////////////////////// void setup () {Serial.begin (9600 ); pinMode (TRIG_PIN, OUTPUT); pinMode (ECHO_PIN, INPUT); pinMode (M1, OUTPUT); pinMode (M2, SAÍDA); pinMode (M3, SAÍDA); pinMode (M4, SAÍDA); randomSeed (analogRead (A0)); ESTADO =0; Serial.println ("O TREINAMENTO COMEÇARÁ EM 5 SEGUNDOS:"); delay (5000);} //////////////////////////// FUNÇÕES DO ROBÔ ////////////// ///////////////////// void Forward () {digitalWrite (M1, LOW); digitalWrite (M2, ALTO); digitalWrite (M3, LOW); digitalWrite (M4, HIGH); } void Backward () {digitalWrite (M1, HIGH); digitalWrite (M2, BAIXO); digitalWrite (M3, HIGH); digitalWrite (M4, BAIXO);} void Esquerda () {digitalWrite (M1, ALTO); digitalWrite (M2, BAIXO); digitalWrite (M3, LOW); digitalWrite (M4, HIGH);} void Right () {digitalWrite (M1, LOW); digitalWrite (M2, ALTO); digitalWrite (M3, HIGH); digitalWrite (M4, LOW);} void Stop () {digitalWrite (M1, LOW); digitalWrite (M2, BAIXO); digitalWrite (M3, LOW); digitalWrite (M4, LOW);} bool Obstacle_Avoider () {digitalWrite (TRIG_PIN, HIGH); atrasoMicrosegundos (10); digitalWrite (TRIG_PIN, LOW); duração =pulseIn (ECHO_PIN, HIGH); distância =(duração / 2) / 29,1; if (distância <15) {Obstáculo =verdadeiro; } if (distância> 15) {Obstáculo =falso; } atraso (10); return Obstacle;} ////////////////////////////////////////////// END / //////////////////////////////////////////////////////// //////////////////////////////// ROBOT'S Q LEARNING FUNCTIONS //////////////////// //////////////////// float RANDOM (float EXPLORATION_PARAMETER) {/ * ESTA FUNÇÃO ENCONTRA O NÚMERO RANDOM QUE DECIDE SE UMA AÇÃO A SER TOMADA É ALEATÓRIA OU DE Q_TABLE * / float RANDOM_VARIABLE; flutuar PROBABILIDADE; RANDOM_VARIABLE =aleatório (0,100); PROBABILITY =RANDOM_VARIABLE / 100; return PROBABILITY;} float DECAY (float PARAMETER) {/ * ESTA FUNÇÃO É UTILIZADA PARA REDUZIR EPSILON (EXPLORATION PARAMETER) COM O TEMPO. FINALMENTE NO FINAL VOCÊ OBTEM RID EPSILON E O ROBOT APRENDE A EVITAR OBSTÁCULOS NOS SEUS PRÓPRIOS * / PARAMER * 0,98; // PARÂMETRO AQUI ESTÁ O PARÂMETRO EPSILON return;} int GET_STATE () {int STATE_NUMBER; STATE_NUMBER =aleatório (0,10); return STATE_NUMBER;} float MAX (float Q_Table [] [4], int NEXT_S) {/ * ESTA FUNÇÃO ENCONTRA O MAIOR NÚMERO NA Q_TABLE [NEXT_STATE]. O PAPEL PRINCIPAL DESTA FUNÇÃO É ENCONTRAR O PARÂMETRO Q_MAX * / float LIST [4]; float N1; float N2; flutuante MAX_VALUE =0,0; float DIFF; para (int b =0; b <=3; b ++) {LISTA [b] =Q [NEXT_S] [b]; } para (int j =0; j <=2; j ++) {if (MAX_VALUE> LIST [j]) {N1 =MAX_VALUE; } senão {N1 =LISTA [j]; } N2 =LISTA [j + 1]; DIFF =N1- N2; if (DIFF> 0) {MAX_VALUE =N1; } mais {MAX_VALUE =N2; }} return MAX_VALUE;} int ARGMAX (float Q_Table [] [4], int S) {/ * ESTA FUNÇÃO ENCONTRA O ÍNDICE DO MAIOR VALOR Q NA Q TABLE [STATE] * / float ARRAY [4]; float N1; float N2; flutuante MAX_VALUE =0,0; float DIFF; float NUMBER; int MAX_INDEX; para (int u =0; u <=3; u ++) {ARRAY [u] =Q_Table [S] [u]; } para (int p =0; p <=2; p ++) {if (MAX_VALUE> ARRAY [p]) {N1 =MAX_VALUE; } senão {N1 =ARRAY [p]; } N2 =ARRAY [p + 1]; DIFF =N1- N2; if (DIFF> 0) {MAX_VALUE =N1; } mais {MAX_VALUE =N2; }} para (int r =0; r <=3; r ++) {NUMBER =ARRAY [r]; if (NUMBER ==MAX_VALUE) {MAX_INDEX =r; pausa; }} return MAX_INDEX;} void Update (float Q_TABLE [] [4], int S, int NEXT_S, int A, int ACTIONS [], int R, float LEARNING_RATE, float DISCOUNT_FACTOR) {/ * ESTA FUNÇÃO ATUALIZA A TABELA Q E VALORES Q. ESTA ATUALIZAÇÃO CONTINUA ACONTECENDO ATÉ AS EXTREMIDADES PRINCIPAIS DO LOOP. NO FINAL DOS EPISÓDIOS A TABELA Q ESTÁ PREENCHIDA COM VÁRIOS VALORES. QUANTO MAIORES OS VALORES, MAIOR IMPORTÂNCIA QUE A AÇÃO TEM NESSE ESTADO EM PARTICULAR. "Q_OLD" É O VALOR ANTIGO QUE A MATRIZ Q TEM. ESTE É O VALOR QUE É ATUALIZADO EVENTUALMENTE. Q_NEW É O NOVO Q_VALUE CALCULADO PELA FÓRMULA Q LEARNING. A FÓRMULA DE APRENDIZAGEM Q USADA AQUI É BASEADA NA EQUAÇÃO DE BELLMAN USA A ABORDAGEM DE APRENDIZAGEM DE DIFERENÇA TEMPORAL. (A ABORDAGEM DE MONTE CARLO NÃO FUNCIONA NESTE CASO DE OBSTÁCULO EVITANDO O ROBÔ. * / Q_OLD =Q_TABLE [S] [A]; Q_MAX =MAX (Q_MAX =MAX (Q_MAX =MAX () NEXT_S); Q_NEW =(1-LEARNING_RATE) * Q_OLD + LEARNING_RATE * (R + DISCOUNT_FACTOR * Q_MAX); Serial.print ("Q VALUE:"); Serial.println (Q_NEW); Q_TABLE [S] [A] =Q_NEW;} //////////////////////////////////////////////////// ///////////FIM////////////////////////////////////// //////////////////////////////////////////////////////// //////////////// START OF MAIN LOOP //////////////////////////////// ///////////////////// void loop () {//////////////////////////// ///////////////TREINAMENTO////////////////////////////////// ////////// for (int I =0; I  

Esquemas