Évitement d'obstacles à l'aide de l'intelligence artificielle

Outils et machines nécessaires

	Fer à souder (générique)
	Fil à souder, sans plomb
	Flux de soudure, soudure
	Pompe à dessouder, Deluxe SOLDAPULLT®
	Dénudeur et coupe-fil, 18-10 AWG / 0.75-4mm² Fils de capacité
	Pistolet à colle chaude (générique)
	Ruban double face

Applications et services en ligne

Arduino IDE

À propos de ce projet

OBSTACLE ÉVITER LE ROBOT À L'AIDE DE L'APPRENTISSAGE IA/RENFORCEMENT

Énoncé du problème : L'objectif principal est d'apprendre à éviter les obstacles dans « N » Épisodes et d'apprendre l'action optimale. Dans ce cas, supposons que nous ayons besoin de notre Robot pour apprendre l'action optimale en tant que « Droite ».

Algorithme de renforcement utilisé : Q apprentissage

Comment le L298N entraîne deux moteurs à courant continu :

Comment le capteur HC-SR04 calcule la distance :

Termes importants dans l'apprentissage par renforcement :

1. ÉTAT : C'est la situation dans laquelle se trouve le Robot. Ici, pour un robot de base évitant les obstacles, il y a au total 2 états …… Le 1er état est lorsqu'il n'y a pas d'obstacle à proximité et le 2ème état dans lequel il y a un obstacle devant lui. (Quand j'ai écrit le code, j'ai supposé 10 différents les états peuvent être dans lesquels attendu la même action. La raison pour laquelle j'ai fait cela pour illustrer un environnement plus complexe.)

2. ACTION : Dans un état particulier, le robot effectue une action particulière. Il y a 4 actions que le robot peut effectuer dans le 2ème état :« AVANT », « ARRIÈRE », « GAUCHE », « ARRÊTER ». Dans le 1er état, le robot peut effectuer 4 actions mais pour faciliter les choses, j'ai supposé que le robot ne peut effectuer qu'une seule action qui est « AVANT »( C'est parce qu'il est boiteux d'envisager des actions telles que GAUCHE ou EN ARRIÈRE lorsqu'il n'y a pas d'obstacles à proximité.

int ACTIONS =[0,1,2,3]

/* ICI :
0 =AVANT
1 =ARRIERE
2 =STOP
3 =DROIT*/ 

3. ÉTAT SUIVANT : Il s'agit de l'état dans lequel le robot entre lorsqu'il effectue une « ACTION » particulière dans son « ÉTAT ». actuel En obstacle évitant le boîtier du robot, l'ÉTAT SUIVANT peut être soit un "CRASHED" état ou un « SURVÉ » État. (Ici, l'état SURVIVE est le même que l'état de départ dans lequel se trouve le robot lorsque son épisode commence.)

/*APRÈS AVOIR EFFECTUÉ UNE ACTION LE ROBOT PASSE À L'ÉTAT SUIVANT DANS CE CAS D'OBSTACLE 
EN ÉVITANT LE ROBOT*/

int NEXT_STATE;
int STATE =0;
NEXT_STATE =STATE+1; 

4. TABLEAU Q / MATRICE Q : Ce tableau est formé du Nombre d'« ÉTATS » et du Nombre d'« ACTIONS ». Dans le cas du robot d'évitement d'obstacles, ce tableau est donné par :

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 }} ; 

Ici N_STATES =10 AND N_ACTIONS =4. ici "0.0" indique que toute action peut être effectuée à partir de l'une des 4 actions possibles. si vous souhaitez toutefois éliminer une particule action dans un état remplace simplement "0.0" par "-1.0" dans la matrice. "-1.0" indique que l'action ne peut pas être exécutée dans cet état. ici, on suppose que nous avons 10 états différents, chaque état attendant la même action. si vous voulez que votre robot apprenne des actions différentes dans chaque état, modifiez les récompenses à partir de la matrice de récompense dans le code

5. ÉTAT DU TERMINAL : C'est le dernier état dans lequel le robot peut se trouver. Pour le robot évitant les obstacles, cet état n'existe pas car nous n'avons pas d'état terminal et voulons que notre robot continue d'apprendre pour toujours.

6. MATRICE DE RÉCOMPENSE : Cette table ou matrice est utilisée pour récompenser le robot pour certaines actions. La récompense est positive ou négative selon la qualité de l'action.

int RÉCOMPENSES[ÉTATS][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}} ; 

7. ENVIRONNEMENT : Cela peut également être supposé ou considéré comme le monde du Robot. Par exemple, nous, les humains, vivons sur terre, donc fondamentalement, la terre est notre environnement.

Hyperparamètres dans l'apprentissage par renforcement :

1. TAUX D'APPRENTISSAGE (ALPHA) : Le taux d'apprentissage ou la taille du pas détermine dans quelle mesure les informations nouvellement acquises remplacent les anciennes. Un facteur de 0 fait que l'agent n'apprend rien (en exploitant exclusivement les connaissances antérieures), tandis qu'un facteur de 1 fait que l'agent ne considère que les informations les plus récentes (ignorant les connaissances antérieures pour explorer les possibilités). Dans des environnements entièrement déterministes, un taux d'apprentissage ALPHA =1,0 est optimal. Lorsque le problème est stochastique, l'algorithme converge sous certaines conditions techniques sur le taux d'apprentissage qui l'obligent à décroître jusqu'à zéro. En pratique, un taux d'apprentissage constant est souvent utilisé, tel que ALPHA =0,1 pour tous les scénarios.

float ALPHA =0.2 ; 

2. FACTEUR DE REMISE (GAMMA) : Le facteur de remise de 0 détermine l'importance des récompenses futures. Un facteur de 0 rendra l'agent « myope » (ou myope) en ne considérant que les récompenses actuelles, tandis qu'un facteur approchant 1 le poussera à rechercher une récompense élevée à long terme. Si le facteur de remise atteint ou dépasse 1, les valeurs d'action peuvent diverger. Pour GAMMA =1,0, sans état terminal, ou si l'agent n'en atteint jamais un, tous les historiques d'environnement deviennent infiniment longs, et les utilitaires avec des récompenses additives et non actualisées deviennent généralement infinis. Même avec un facteur de remise à peine inférieur à 1, Q l'apprentissage des fonctions conduit à la propagation d'erreurs et d'instabilités lorsque la fonction valeur est approchée avec un réseau de neurones artificiels. Dans ce cas, commencer avec un facteur de remise inférieur et l'augmenter jusqu'à sa valeur finale accélère l'apprentissage.

flotteur GAMMA =0.9 ; 

3. TAUX D'EXPLORATION (EPSILON) : Ce paramètre décide dans quelle mesure le robot doit explorer l'environnement. Explorer l'environnement signifie effectuer des actions aléatoires et analyser les résultats via les valeurs Q. Habituellement, dans Q Learning (contrairement à SARSA), nous nous débarrassons éventuellement de ce paramètre au fur et à mesure que Robot apprend de plus en plus. Mais dans ce projet, nous n'allons pas nous débarrasser d'Epsilon car nous n'avons pas d'état terminal. Dans ce cas, Epsilon réduira dans une certaine mesure, puis sera à nouveau réinitialisé lorsqu'il descendra en dessous d'une valeur seuil. Cela garantira que le robot continuera à explorer jusqu'à sa vie, tout comme nous, les humains.

flotteur EPSILON =0.75 ; 

ALGORITHME Q-LEARNING :

• Initialisez le tableau des valeurs Q, Q(s, a) . J'ai initialisé ces valeurs à 0.0.
• Observez l'état actuel, s .
• Choisissez une action, une , pour cet état basé sur l'une des politiques de sélection d'action expliquées ici à la page précédente (📷-soft, 📷-greedy ou softmax).

/////////////////////////Politique gourmande d'Epsilon/////////////// ///////////////

PROB =RANDOM(EPSILON);
if (PROB<=EPSILON) //EXPLOREZ LES ACTIONS
{
ACTION =random(0,4) ;
DRAPEAU =2 ;
}
else //EXPLOITER LES ACTIONS DE LA TABLE Q
{
ACTION =ARGMAX(Q,ÉTAT);
DRAPEAU =2;
}

• Passez à l'action et observez la récompense, r , ainsi que le nouvel état, s' .
• Mettre à jour la valeur Q de l'état en utilisant la récompense observée et la récompense maximale possible pour l'état suivant. La mise à jour se fait selon la formule et les paramètres décrits ci-dessus.
• Définissez l'état sur le nouvel état et répétez le processus jusqu'à ce qu'un état terminal soit atteint.
• Pour comprendre le Q-learning mieux vaut visiter ce lien :https://towardsdatascience.com/a-beginners-guide-to-q-learning-c3e2a30a653c

//////////////////Mise en œuvre de la formule 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;

Vidéo de travail :n'oubliez pas de regarder la vidéo de travail d'AI Robot :)

Code

• Robot d'évitement d'obstacles utilisant Q-LEARNING

Robot d'évitement d'obstacles utilisant Q-LEARNINGC/C++

Schémas