Evitación de obstáculos utilizando inteligencia artificial

Código

• Robot para evitar obstáculos con Q-LEARNING

Robot para evitar obstáculos con Q-LEARNING C / C ++

 / * Este es un Robot para Evitar Obstáculos usando el Aprendizaje por Refuerzo / IA Autor de este Proyecto:Varun Walimbe Algoritmo usado en este proyecto:Q learning ¿Cómo Funciona Evitar Obstáculos? 1.Ultrasonic El sensor se usa para medir la distancia desde el obstáculo usando sus pines de eco y gatillo.2.Cuando se mide la distancia y si es menor de 20 cm, entonces hay un obstáculo cerca; de lo contrario, el robot está seguro y continúa hacia adelante.3.Si se detecta un obstáculo, el robot toma giro a la izquierda o a la derecha dependiendo de la situación ¿Cómo funciona la evitación de obstáculos basada en IA? (aprendizaje Q) 1.Aquí el primer paso del artículo superior sigue siendo el mismo.Sin embargo, el segundo paso es diferente.2.Una lista de acciones del robot son inicializado primero. Por ejemplo, en este caso, las acciones de Robot son:Izquierda, Adelante, Atrás, Detener. Cuando el Robot se acerca a un obstáculo, es necesario que realice una acción. Sin embargo, tenga en cuenta que, en este caso, el Robot no sabe qué acción tomar, ya que no está preprogramado y aprenderá por sí solo para evitar obstáculos. 0 Cuando el robot se detiene y retrocede, recibe una recompensa de -5 Cuando el robot continúa avanzando ignorando los obstáculos, recibe una recompensa de -10 Cuando el robot se mueve hacia la izquierda tan pronto como se detecta un obstáculo, obtiene una recompensa de + 105. aprende por sí solo a evitar obstáculos mediante el mecanismo de recompensa. * /////////// PARÁMETROS DE HARDWARE DEL ROBOT ////////////////////// int TRIG_PIN =7; int ECHO_PIN =8; int duración; distancia de flotación; int M1 =13; int M2 =12; int M3 =11; int M4 =10; bool Obstacle =false; int FLAG; ////////// ///////////////FIN////////////////////////////////// //////////////////////////////// Q PARÁMETROS DE APRENDIZAJE /////////////// //////////////////////////// flotar ALPHA =0.1; // TASA DE APRENDIZAJEfloat GAMMA =0.5; // FACTOR DE DESCUENTOfloat EPSILON =0.90; // PARÁMETRO DE EXPLORACIÓNint RECOMPENSA; // RECOMPENSA POR REALIZAR UNA ACCIÓNint EPISODES =100; int STATE; // ESTADO ACTUAL DEL ROBOTint ACTION =0; // ACCIÓN REALIZADA POR EL ROBOT (0:HACIA ADELANTE, 1:HACIA ATRÁS, 2; PARAR, 3:IZQUIERDA) float PROB; // UTILIZADO PARA EPSILON DECAY bool ACTION_TAKEN =false; // ESTA VARIABLES NOS DICE SI SE TOMA UNA ACCION O NO EN SIGUIENTE_ESTADO; // SIGUIENTE ESTADO DEL ROBOTconst int ESTADOS =10; // NÚMERO DE ESTADOS EN EL MEDIO AMBIENTE int ACTIONS [4] ={1,2,3,4}; const int NUMBER_OF_ACTIONS =4; // TOTAL TENEMOS 4 ACCIONES HACIA ADELANTE, HACIA ATRÁS, IZQUIERDA Y PARADA / * ESTA ES LA Q MATRIX O Q TABLE. ESTE ES BÁSICAMENTE EL DIARIO QUE BUSCARÁ EL ROBOT ANTES DE REALIZAR UNA ACCIÓN. BASADO EN LA ACCIÓN, EL ROBOT GANARÁ UNA RECOMPENSA Y EL VALOR Q SE ACTUALIZARÁ EN ESTA Q TABLA. AQUÍ HE CONISDIDO 10 ESTADOS. HE ASUMIDO QUE TODOS LOS ESTADOS SON DIFERENTES AUNQUE SON MISMOS. BÁSICAMENTE EL ROBOT PARA EVITAR OBSTÁCULOS CONTIENE SOLO DOS ESTADOS, es decir:1:CUANDO ESTÁ LEJOS DEL OBSTÁCULO 2:CUANDO ESTÁ CERCA DEL OBSTÁCULO, PERO AQUÍ PARA ILUSTRAR MÁS QUE EL COMPLEJO HE ASUMIDO ENTORNO 10 ESTADOS DIFERENTES AQUÍ ESPERAN LA MISMA / DIFERENTE ACCIÓN. * / Float Q [ESTADOS] [NUMBER_OF_ACTIONS] ={{0.0,0.0,0.0,0.0}, // LO MÁS IMPORTANTE DE TODOS ES LA TABLA Q. {0.0,0.0,0.0,0.0}, // ESTÁ FORMADO POR ESTADOS COMO SUS FILAS {0.0,0.0,0.0,0.0}, // Y COLUMNAS COMO SU NÚMERO DE ACCIONES {0.0,0.0,0.0,0.0}, / / INICIALIZADO A CERO EN EL INICIO {0.0,0.0,0.0,0.0}, // ESTO SE ACTUALIZARÁ EN EL 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 ES UNA MATRIZ DE RECOMPENSAS O TABLA DE RECOMPENSAS. ESTE ES RESPONSABLE DE DAR RECOMPENSA AL ROBOT POR REALIZAR UNA ACCIÓN DETERMINADA. ALMACENA LA RECOMPENSA POR CADA ACCIÓN TOMADA EN EL ESTADO. LA RECOMPENSA SERÁ POSITIVA SI LA ACCIÓN REALIZADA ES BUENA Y NEGATIVA SI LA ACCIÓN PRODUCE MALOS RESULTADOS. * / Int REWARDS [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}}; ////////////////////////////////////////////FIN///// //////////////////////////////////////////////////// //////////// PARÁMETROS DE ACTUALIZACIÓN DE APRENDIZAJE Q //////////// float Q_OLD; float Q_NEW; float Q_MAX; ///////////// ///////////// FIN ////////////////////////// configuración vacía () {Serial.begin (9600 ); pinMode (TRIG_PIN, SALIDA); pinMode (ECHO_PIN, ENTRADA); pinMode (M1, SALIDA); pinMode (M2, SALIDA); pinMode (M3, SALIDA); pinMode (M4, SALIDA); randomSeed (analogRead (A0)); ESTADO =0; Serial.println ("EL ENTRENAMIENTO COMENZARÁ EN 5 SEGUNDOS:"); delay (5000);} //////////////////////////// FUNCIONES DEL ROBOT ////////////// /////////////////// void Forward () {digitalWrite (M1, LOW); escritura digital (M2, ALTA); escritura digital (M3, BAJA); escritura digital (M4, ALTA); } void Backward () {digitalWrite (M1, HIGH); escritura digital (M2, BAJA); escritura digital (M3, ALTA); escritura digital (M4, BAJA);} void Izquierda () {escritura digital (M1, ALTA); escritura digital (M2, BAJA); escritura digital (M3, BAJA); escritura digital (M4, ALTA);} void Derecha () {escritura digital (M1, BAJA); escritura digital (M2, ALTA); escritura digital (M3, ALTA); digitalWrite (M4, LOW);} void Stop () {digitalWrite (M1, LOW); escritura digital (M2, BAJA); escritura digital (M3, BAJA); digitalWrite (M4, LOW);} bool Obstacle_Avoider () {digitalWrite (TRIG_PIN, HIGH); delayMicroseconds (10); digitalWrite (TRIG_PIN, BAJO); duración =pulseIn (ECHO_PIN, HIGH); distancia =(duración / 2) /29.1; if (distancia <15) {Obstáculo =verdadero; } if (distancia> 15) {Obstáculo =falso; } retraso (10); Obstáculo de retorno;} ////////////////////////////////////////////// FIN / //////////////////////////////////////////////////// //////////////////////////// FUNCIONES DE APRENDIZAJE Q DEL ROBOT //////////////////// ////////////////// float RANDOM (float EXPLORATION_PARAMETER) {/ * ESTA FUNCIÓN ENCUENTRA EL NÚMERO ALEATORIO QUE DECIDE SI UNA ACCIÓN A TOMAR ES ALEATORIA O DE Q_TABLE * / float RANDOM_VARIABLE; PROBABILIDAD de flotar; RANDOM_VARIABLE =aleatorio (0,100); PROBABILIDAD =RANDOM_VARIABLE / 100; return PROBABILITY;} float DECAY (float PARAMETER) {/ * ESTA FUNCIÓN SE UTILIZA PARA REDUCIR EPSILON (PARAMETRO DE EXPLORACION) CON EL TIEMPO. FINALMENTE AL FINALIZARTE EPSILON Y EL ROBOT APRENDE A EVITAR OBSTÁCULOS EN SU PROPIO * / PARAMETER =PARAMETER * 0,98; // PARÁMETRO AQUÍ ESTÁ EL PARÁMETRO de retorno de EPSILON;} int GET_STATE () {int STATE_NUMBER; STATE_NUMBER =aleatorio (0,10); return STATE_NUMBER;} float MAX (float Q_Table [] [4], int NEXT_S) {/ * ESTA FUNCIÓN ENCUENTRA EL NÚMERO MÁS GRANDE EN Q_TABLE [NEXT_STATE]. EL PAPEL PRINCIPAL DE ESTA FUNCIÓN ES ENCONTRAR Q_MAX PARAMETER * / float LIST [4]; flotador N1; flotar N2; flotador MAX_VALUE =0.0; flotar DIFF; para (int b =0; b <=3; b ++) {LIST [b] =Q [NEXT_S] [b]; } for (int j =0; j <=2; j ++) {if (MAX_VALUE> LIST [j]) {N1 =MAX_VALUE; } más {N1 =LISTA [j]; } N2 =LISTA [j + 1]; DIFF =N1-N2; si (DIFF> 0) {MAX_VALUE =N1; } más {MAX_VALUE =N2; }} return MAX_VALUE;} int ARGMAX (float Q_Table [] [4], int S) {/ * ESTA FUNCIÓN ENCUENTRA EL ÍNDICE DEL VALOR Q MÁS GRANDE EN Q TABLE [ESTADO] * / float ARRAY [4]; flotador N1; flotar N2; flotador MAX_VALUE =0.0; flotar DIFF; número flotante; 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; } más {N1 =ARRAY [p]; } N2 =ARRAY [p + 1]; DIFF =N1-N2; si (DIFF> 0) {MAX_VALUE =N1; } más {MAX_VALUE =N2; }} para (int r =0; r <=3; r ++) {NUMBER =ARRAY [r]; si (NÚMERO ==VALOR_MÁX) {INDEX_MÁX =r; descanso; }} 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 FUNCIÓN ACTUALIZA LA TABLA Q Y VALORES Q. ESTA ACTUALIZACIÓN SIGUE SUCEDIENDO HASTA QUE TERMINE EL BUCLE PRINCIPAL. AL FINAL DE LOS EPISODIOS, LA TABLA Q ESTÁ LLENA DE VARIOS VALORES. A MAYORES VALORES, MAYOR IMPORTANCIA TIENE LA ACCIÓN EN ESE ESTADO EN PARTICULAR. "Q_OLD" ES EL VALOR ANTIGUO QUE TIENE LA MATRIZ Q. ESTE ES EL VALOR QUE SE ACTUALIZA EVENTUALMENTE. Q_NEW ES EL NUEVO Q_VALUE QUE ES CALCULADO POR LA FÓRMULA DE APRENDIZAJE DE Q. LA FÓRMULA DE APRENDIZAJE Q UTILIZADA AQUÍ SE BASA EN LA ECUACIÓN DE BELLMAN UTILIZA UN ENFOQUE DE APRENDIZAJE DE DIFERENCIA TEMPORAL (EL ENFOQUE DE MONTE CARLO NO FUNCIONARÁ EN ESTE CASO DE ROBOT PARA EVITAR OBSTÁCULOS. * / 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;} ////////////////////////////////////////////////// ///////////FIN////////////////////////////////////// //////////////////////////////////////////////////// //////////////// INICIO DEL BUCLE PRINCIPAL //////////////////////////////// /////////////////// bucle vacío () {//////////////////////////// ///////////////CAPACITACIÓN////////////////////////////////// ////////// for (int I =0; I   
 
   Esquemas     
   obstacle_avoiding_robot_using_ai_DcoMCWIOFm.fzz 
 

            


            

               Atenuación de luces con PWM usando el botón pulsador        
                Model Rail Digital DCC Command Station Arduino y aplicación gratuita