Discover our
resources

Welcome

‍

> You've just bought the solution and want to get started with it: start by Installing the software, then go to the page corresponding to the robot you want to use (AlphAI, Thymio, mBot, Lego, etc.). 

> You've come to discover our solution. Discover our suggested activities in video on the activity pages by robot (AlphAI, Thymio, mBot, Lego, etc.).

Software installation

The software is designed to operate without an Internet connection (except for license activation and updates).

It does, however, require a wifi connection (recommended) or Bluetooth to communicate with the robot.

‍

If you haven't purchased a license yet, you can take advantage of a 15-day trial version!

‍

Windows installation

1. Download the software 
2. Launch the installation program
3. Follow the instructions, then launch the software!

This screen appears once the software has been downloaded:

System requirements:

• Windows 8.1 minimum
• 4 GB RAM
• 2 GB hard disk space
• OpenGL version ≥ 2.1
• Internet access (during installation only for license retrieval)

‍

* Windows 7 is not supported by Python 3.9, so our software cannot be installed on it. Please contact us for installation assistance.

‍

‍

Mac installation 

1. Téléchargez le script d’installation (clic droit + enregistrer sous…)
2. Open the Terminal application
3. Exécutez la commande :
   sh ~/Downloads/AlphAI-1.8.10.7_installer.sh
   Cela devrait provoquer le téléchargement et l’installation de AlphAI.
4. Pour lancer le logiciel, exécutez simplement la commande : alphai
5. Le mot de passe de votre ordinateur vous sera demandé : saisissez-le puis appuyez sur la touche entrée et patientez quelques instants. Le logiciel se lance !

‍

System requirements:

• Mac OS
• 4 GB RAM
• 2 GB hard disk space
• OpenGL version ≥ 2.1
• Internet access (during installation only for license retrieval)

‍

En cas de difficulté, vous pouvez vous reporter à la page FAQ.

Linux installation

1. AlphAI est compilé pour fonctionner avec python 3.9 (idéalement python 3.9.13). Si vous avez un environnement python 3.9, vous pouvez utiliser celui-ci. Dans le cas contraire, vous pouvez télécharger python 3.9.13 à l’adresse suivante :
   https://www.python.org/downloads/release/python-3913/.
   Dans la suite des instructions, la commande python3 fait référence à cet environnement python 3.9.
2. Téléchargez une version du logiciel AlphAI : Téléchargez le script d’installation.
3. Unzip the downloaded folder to the location where you want to install AlphAI.
4. Ouvrez un terminal et rendez-vous dans le dossier nouvellement créé, par exemple en utilisant la commande : cd AlphAI-1.8.10.11.
5. In the terminal, run the command: python3 -m pip install -r requirements-mac.txt. This should install all the python libraries needed to run the software.
6. Finalement, pour lancer le logiciel, entrez la commande : sudo python3 Start_Alphai.pyc, puis entrez votre mot de passe utilisateur. Attention, il faudra ici remplacer python3 par un chemin explicite vers l’interpréteur python, par exemple ./python3 ou ~/Documents/AlphAI/alphaienv/bin/python3, car sinon c’est l’interpréteur par défaut qui va se lancer.

‍

System requirements:

• Ubuntu 18
• 4 GB RAM
• 2 GB hard disk space
• OpenGL version ≥ 2.1
• Internet access (during installation only for license retrieval)

‍

En cas de difficulté, vous pouvez vous reporter à la page FAQ.

License activation

‍

Lors du premier lancement du logiciel, vous allez voir apparaître la fenêtre d’activation de licence.

‍

‍

Make sure you have an Internet connection, and choose one of the following options:

‍

Cochez la case Version d’essai.

‍Dans ce cas, vous avez la possibilité d’utiliser le logiciel gratuitement sur cet ordinateur pendant une durée de 15 jours. Attention : cette option ne peut être activée qu’une seule fois par ordinateur !

‍

Utilisez une clé d’activation.‍

Cela vous permettra d’utiliser le logiciel sans condition de durée. Pour cela, entrez votre clé d’activation dans le champ prévu à cet effet et sélectionnez une période de validité. À la fin de la période de validité, vous devrez réactiver votre licence. Afin de ne pas égarer celle-ci, vous avez la possibilité de sauvegarder votre clé d’activation sur l’ordinateur.
⚠️ Attention : cela rend possible la réactivation de la licence sur cet ordinateur par un simple clic, ne sauvegardez donc pas votre clé d’activation sur un ordinateur qui ne vous appartient pas !

‍

Réactivez votre licence grâce à une clé enregistrée, en cochant la case utiliser la clé enregistrée. Vous devrez également sélectionner la durée de la nouvelle période de validité.

The following window asks you to provide us with some information:

‍

Cette étape n’est pas obligatoire, mais nous vous prions de bien vouloir remplir les différents champs, ces informations nous permettrons de vous fournir une assistance si besoin mais également de vous informer en cas de mise à jour du logiciel.

‍

About the validity period :

• The validity period is the time during which you can use our software without an Internet connection.
• When this period expires, you will be asked to reactivate your license, a step that requires an Internet connection.
• Each activation key is issued with a limit on the number of simultaneous activations allowed (usually 2 computers or 30 computers).
• If the software is to be used in a classroom, it is advisable to choose an activation period that corresponds to the period of intended use, e.g. until the end of the school year. This way, when the licenses expire, it will be possible to use the software in another room.

Example: Suppose my activation key has a limit of 2 computers. On January 1, I use this key to activate a license on computer A for 6 months (i.e. until June 30). Then, on February 1, I use the same key to activate a license on computer B for 3 months (i.e. until April 30). From February 1 to April 30, the maximum number of activations has been reached, so I can't use my activation key on a third computer. On the other hand, from May 1st, the license on computer B has expired, so I can activate a license on computer C for a period of my choice. Similarly, from July 1, the license on computer A is no longer valid, making it possible to activate on another computer (or renew the license on computer A).

‍

‍

Activation key validity

Duration

‍

Activation keys sold by Learning Robots are perpetual (updates are free for the first year, then subject to an annual subscription). 

Device limits

‍

Depending on the product you choose, your license is valid for 2 or 30 devices.

Thymio features

‍

Licenses for Thymio robots have a few differences from other types of license. The first difference is that the license activation window will not appear when the software is launched, but only when you first connect to a Thymio robot.

‍

If this robot is a simulation, then everything happens as described above.

‍

If this robot is a real Thymio, then the license will be stored on the robot itself and not on your computer. This will then allow you to connect this robot to any computer where the software is installed, even if it doesn't have an active license. However, you will only be able to use your activation key in this way on a single Thymio robot. If you want to use AlphAI with several Thymio robots, you'll need to purchase a license for each robot.

‍

The validity period for real Thymio robots is unlimited.

‍

Pour connecter votre Thymio à votre ordinateur, vous pouvez vous reporter à la fiche Thymio.

‍

Software launch and updates

‍

Launch the software by clicking on the shortcut (PC) or by running the command "alphai" in the terminal and entering your computer password (Mac).

‍

When you launch the software, if you're connected to the Internet, it may detect that an update is required. It launches automatically, and takes just a few minutes!

‍

You will then be taken to the login screen.

Connection screen

‍

Robot selection

In the top right-hand corner of the home screen, you can choose the robot model you'd like to work with. Depending on the license you've purchased, you can choose between :

• the AlphAI robot
• the Thymio robot
• the mBot robot
• the Buddy robot
• Spike robot (LEGO)
• computer (robot-free activities)

Connection modes

Depending on the robot you choose, you can choose between several connection modes: WiFi, Bluetooth (with a dongle or the computer's Bluetooth), or a simulated robot.

For the AlphAI robot, we recommend that you always choose a WiFi connection if possible. If you choose a Bluetooth connection, you'll find a button in the top right-hand corner of your screen that allows you to deactivate the "Bluetooth Low Energy" mode if your robot is an older model.

‍

Simulation

AlphAI and Thymio robots can be used for a wide range of simulation activities. To understand how to use the simulation mode, please refer to the corresponding pages: 

Resources - AlphAI - Robot connection

Resources - Thymio - Connecting to the robot

Instructions and help

En fonction du robot choisi, des boutons en bas de l’écran vous fournissent des instructions et informations pour la connexion au robot et en cas de bugs.Si les instructions ne vous ont pas aidé à résoudre votre problème, vous pouvez vous référer à notre page FAQ.

Main screen

You are now connected to your robot and have reached the main screen. On this page, we present each of the elements you can see on the screen: 

‍

The title

At the top of your screen, a title informs you about the characteristics of the currently selected settings: the learning mode (supervised, reinforcement, or no learning), the control mode (piloted/autonomous), and the number of data recorded in the experience memory during learning.

The robot

‍

On the left of your screen, you can see an image of the robot you are currently using.

For the AlphAI robot, the sensors used in the activity appear in black.
The color of the wheels indicates whether they are blocked (red) or not (green).

You can also see the color of the shell.

Central display

‍

The entire right-hand side of your screen is taken up by the central display. It can contain :

‍

A neural network

On the far left, the input neurons: these are the robot sensors used.

In the middle, the connections and intermediate layers of neurons.

On the far right, output neurons and corresponding action icons: these are the actions the robot can perform.

You can fully parameterize the neural network (AI tab) and modify its visualization (Visualization tab).

‍

A visualization of the state space

Par exemple, dans le cas où l'algorithme choisi est K plus proches voisins, le réseau de neurones sera remplacé par un graphe. Voir l’activité KNN

Visualization of learning data
Once you have provided the robot with example data, you can also display each piece of recorded data on screen: the information provided by the sensors and the associated action. You can correct a bias by deleting a piece of data, modifying an action, etc.

‍

• A combination of these elements
  For example, in the activity Intruder detection, we can see the state space and the neural network

‍

Video screen

If the camera sensor is required for the chosen activity, you'll see a return of the robot's camera in the top left-hand corner of your screen (even for a simulated robot!). If the activity uses the computer's webcam, this is where it will appear.

2D simulation (for the AlphAI robot)

‍

If you have chosen the AlphAI simulated robot for your activity, a 2D arena will appear at the bottom left of your screen, with the simulated robot moving around it live.

If you wish to modify this simulated arena, open the Sensors tab and scroll down: you can then add/remove the central island and choose the color of the interior and exterior walls.

Battery level

‍

If you're connected to an AlphAI robot, at the bottom left of your screen you'll see a battery level indicator. There are 2 states:

• either the battery icon is green, in which case there's nothing to report
• either the battery icon is red or black, in which case we advise you to disconnect the robot from the software and change the batteries immediately 

Changing batteries on an AlphAI robot

‍

‍

Awards and levels

Si vous avez choisi une activité avec apprentissage par renforcement, en bas de votre écran apparaîtront 2 barres : récompense (les récompenses données au robot en fonction des actions effectuées : en rouge si elles sont négatives et en vert si elles sont positives) et niveau (moyenne des récompenses reçues).

Menus

Fichiers

Configurations d’exemple

‍choisissez une configuration d’exemple parmi toutes celles conçues par Learning Robots ! Vous trouverez le détail du déroulement de chaque activité sur les pages ressources du robot utilisé :
Activités AlphAI Capture ecran - Logiciel - Présentation 18 alphai
Activités Thymio Capture ecran - Logiciel - Présentation 18 thymio
Activités mBot Capture ecran - Logiciel - Présentation 18 mBot

Charger

• Load configuration: selects a configuration saved on the computer (.json format)
• Load default configuration: allows you to return to the default configuration.
• Load training data: allows you to load training data that has been saved on your computer (.zip or .npz format - take care to load data that corresponds to the current configuration).
• Load template: allows you to load a template saved on your computer (.zip or .pth format - take care to load a template that corresponds to your current configuration).
  
  

Sauvegarder

• Save configuration: saves the current configuration on the computer (.json format)
• Save as default configuration: saves the current configuration as the default configuration (when you launch the software, this configuration will be loaded automatically).
• Reset configuration: resets and loads the configuration to factory settings
• Save training data: saves current training data on computer
• Save model: saves the current trained model on the computer
  
  

Language

• ‍choisissez dans quelle langue vous souhaitez utiliser le logiciel

‍

Affichage des paramètres

‍choisissez le niveau d'affichage des paramètres entre les modes standard (plus épuré), avancé et expert (toutes les options).
Nous vous conseillons de choisir le mode standard, à moins d’être familier avec AlphAI et avoir de bonnes connaissances en IA.

Activer le mode enseignant

• ‍si vous êtes enseignant, activer ce mode vous permettra d’accéder à de nouvelles fonctionnalités. Vous aurez besoin pour y accéder de votre clé d’activation.
  Par exemple, dans le menu aide, vous pouvez cliquer sur “Informations sur les licences” pour connaître la liste d'appareils sur lesquels la licence a été activée.
  
  

Autres paramètres du programme...

• Font size: change the font size on the software if you wish to have a better view, for example, of neural network connection weights.
• Big Brother: This option is used in particular in our "Ethics of AI" activity. Once activated by the teacher prior to the session, the program saves the images taken by the camera, without the students' knowledge, in a sub-folder of the software installation directory, named "to_upload" expressly to provoke reactions.
  The teacher can show this folder to the students at a later stage to discuss with them the issues surrounding data collection, with or without consent.
  The saved images are automatically destroyed when the program is closed. AlphAI software does not collect or transmit any information, and in fact works offline.
  This option can only be used for educational purposes.

‍

• Outils
  • Change configuration folder: allows you to change the location of the configuration folder on your computer. This folder contains log files and program settings.
  • Download robot event log: allows you to download the robot's log file (requires WiFi connection).
    Useful to pass on to us in the event of a bug!
  • Robot test: to detect any hardware faults on the robot
    
    From the login screen, you can also find :
  • Robot update: force robot update if it didn't work automatically
  • Diagnose robot start-up: check that the robot starts up correctly (this test takes about 20 seconds. Another window opens when the test is complete)

‍

• Aides
  • Resources: access the resources and help center provided by Learning Robots: find out everything there is to know about the AlphAI software, all the instructions and activities for each robot, the FAQ, etc.
  • Change log: access the list of updates
  • About AlphAI: tells you which version of AlphAI you are currently using

Report a bug: if you encounter a problem that you can't solve, this form lets you send us a message that will be associated with the software log, and thus help us solve your problem (please enter your email address so we can contact you if necessary).

Controls

Autonomie

Capture ecran - Logiciel - Présentation 6

Control your robot's autonomy with these buttons:

• Autonomous: the robot is continuously autonomous
• Step by step: click to watch your robot make one decision, and one decision only! The robot will take just one step each time you press the button.
• Exploration: in reinforcement learning mode, this button lets you force your robot to occasionally attempt a random action (configurable in the AI tab).

‍

Apprentissage

‍Capture ecran - Logiciel - Présentation 7

Control your robot's learning curve:

• Learning: if this button is selected, the robot stores the data supplied in its experience memory and changes the connections in its neural network. It's learning!
  In expert display mode, you have more control:some text
  • acquire data: if this button is activated, the robot memorizes the actions it performs.
  • Train the model: if this button is activated, the learning algorithm evolves the values of the model parameters.
• Manual editing: in "Manual editing" activities, click this button to modify neural network parameters directly from the interface.
• Forget action: if you click on this button, the robot forgets the last piece of data it learned: very useful if you make a mistake during the learning phase!
• Reset AI: Clicking this button resets the training data and the model, so you can start learning the robot all over again!
  In expert display mode, you have more control:some text
  • Reset data: deletes stored training data
  • Reset model: model parameters are reset.

‍

Graphes

‍Capture ecran - Logiciel - Présentation 8

This button opens a pop-up window giving you information about your robot's training, and graphs that present this data visually. 

Capture ecran - Logiciel - Présentation 8bis

This graph tracks the robot's progress by displaying its rewards and the error of its predictions over time. If the robot is making good progress, the reward graph should increase and the error graph should decrease.

If there is too much noise in the data, you can smooth the curves, for example over 2 minutes, by clicking on Smoothing - 2 minutes.

‍

Settings (for AlphAI)

Use this button to set your robot's parameters:

• Speed (from 15 to 50): you can set the robot's speed, depending on the activity and the size of the arena used
  Capture ecran - Logiciel - Présentation 9a
• Trajectory correction: the robot may have a small trajectory error. Use this tool to correct it (test using the go straight action)
  Screenshot - Software - Presentation 9b
• Accelerated simulation: if you've chosen a simulated robot, this button lets you accelerate the robot's decision-making and actions, instead of imitating real speed.
  Capture ecran - Logiciel - Présentation 9c

‍

Log off

Use this button to disconnect from the robot, to change the batteries or when your session is over!

⚠️ If you disconnect from the robot, you will automatically return to the home screen. However, if you reconnect the robot and restart the activity without quitting the software, neither the configuration nor your training data will be lost.

Capture ecran - Software - Presentation 10

‍

‍

Tabs

Onglet capteurs

Capture ecran - Logiciel - Présentation 11

The Sensors window lets you select the robot sensors to be used.

Click on a sensor to choose one of the possible usage options.

Find out more about the different sensors used in different robots:

AlphAI robot sensors

Thymio robot sensors

mBot robot sensors

You can also choose the number of instants, and in the case of a simulated robot, change the arena parameters.

Onglet actions

Capture ecran - Logiciel - Présentation 12

The Actions window lets you choose which actions the robot can perform.

Click on an action to add it to the neural network.
⚠️ Adding a new action will delete the robot's experience memory.

‍

Discover the different actions used depending on the robots involved:

AlphAI robot shares

Thymio robot actions

mBot robot shares

‍

You can also choose speed, duration (from 0.1s to 2s), and whether or not you want the robot to pause between actions, and for how long.

‍

Onglet récompenses

Capture ecran - Logiciel - Présentation 13

If you have launched an activity with reinforcement learning, you can use the Rewards tab to choose the type of reward and its configuration.

Vitesse et blocage

‍Récompensez le robot si il va vite, punir s’il s’arrête. Vous pouvez personnaliser la récompense obtenue par le robot quand il effectue une action de virage, et la valeur de la pénalité quand il se bloque ou recule.

Couleur dans l’image‍

Récompensez le robot si beaucoup de pixels de la caméra sont d’une certaine couleur.
Vous pouvez personnaliser la teinte, la luminance et la saturation.

Couleur et blocage‍

Récompensez le robot si beaucoup de pixels de la caméra sont d’une certaine couleur, et le punir s'il s’arrête.
Vous pouvez personnaliser la teinte, la luminance et la saturation.

Suivi de ligne

‍Récompensez le robot si détecte du noir juste en dessous de lui. Vous pouvez personnaliser le seuil de détection de blocage.

Code Python‍

Paramétrez vos propres récompenses en utilisant un fichier de code Python

‍

Onglet IA

‍Capture ecran - Logiciel - Présentation 14

The A.I. tab lets you choose how the robot is trained, for example, whether to use supervised learning or Deep Q Learning. It also lets you set the parameters of the various algorithms.

‍

" " = all modes

"advanced and expert only

" " = expert only

‍

• Type of learning

‍

• Algorithm: Select the AI algorithm used.
  
  
• Learning speed: Increase for faster learning... but decrease if divergence errors appear.
  
  
• Gamma: Adjusts the importance given to immediate rewards (value close to 0) in relation to more distant rewards (value close to 1).
  
  
• Exploration: Frequency of explorations (value between 0 and 1).
  
  
• Layers of intermediate neurons: Number of neurons in each intermediate layer e.g. leave blank to connect inputs directly to outputs, put "100 50" for two intermediate layers of 100 and 50 neurons respectively.
  
  
• Activation function: choice of activation function for intermediate layers.
  
  
• 2 neurons per binary variable: Check to have binary inputs represented by 2 neurons (of which one and only one will always be activated); Uncheck to use only 1 neuron.
  
  
• Neuronal bias: Check to allow neurons to adjust their activation threshold (this is equivalent to considering that all neurons receive a constant input that they can adjust, not represented in the graphical interface).
  
  
• Experience memory: Check to ensure that the AI continues to learn from past actions and rewards.

‍

Onglet Visualisation‍

Capture ecran - Logiciel - Présentation 15

The View tab lets you choose what is displayed or not on the main screen.

‍

" " = all modes

"advanced and expert only

‍

• Display type: neural network, state space, or both
  
  
• Animation: animating activity in the network (movement from inputs to outputs)
  
  
• Connections : Show network connections
  
  
• Apprenticeships: Show apprenticeshipsessome text
  • green: connections intensify
  • red: connections decreasing
    
    
• Synaptic activity: Display activity in the text network
  • yellow: exciting activities
  • blue: inhibition activities

‍

• Input/output values : Display values of input and output neurons
  
  
• Connection values : Display connection weights. This option automatically activates the I/O display.
  
  
• Spacing between neurons: switches input neurons from vertical to horizontal mode
  
  

For AlphAI robot only: you can change the color of the shell. Note: the robot will memorize its new color, which will then appear on the connection screen.

‍

Python programming tools

‍

• AlphAI API documentation

This document contains all the information you need to use the AlphAI API:

https://drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view

• In the IA tab of the software

Capture ecran - Software - Presentation 16

You can choose "Python code" for the algorithm parameter.

A pop-up window appears, prompting you to choose between creating a new file or opening an existing one.

This file is used to write python code that will be executed by the software.

• In the Software Rewards tab (AlphAI only)

Capture ecran - Software - Presentation 17

Program your own reward function by clicking on the "python code" button.

‍

Updates

Learning Robots works continuously to develop the software's functionality and improve the user experience.

‍

That's why we carry out updates from time to time, which start after approval when the software is launched if you're connected via WiFi. They only take a few minutes!

‍

We advise you to update all workstations at the same time, to ensure you have the same version of the software on each workstation.

‍

Link to FAQ updates

‍

List of modifications

‍

Version 1.8.10 (April 5, 2024)

• New "computer" environment for robot-free learning.
• New webcam sensor available for Thymio, mBot and computer.
• Portuguese translations available.

Version 1.8.9 (February 16, 2024)

• Windows installer improvements.
• Better management of configuration folder location.

Version 1.8.8 (January 31, 2024)

• German and Spanish translations.
• Possibility of manually changing the configuration folder to suit specific needs.

Version 1.8.7 (December 13, 2023)

• Improvements to graphical representations of state space.
• Fixed a bug that prevented the use of python code mode for reward programming.

Version 1.8.6 (December 11, 2023)

• Italian and Dutch translations updated.
• Other minor improvements and bug fixes.

Version 1.8.5 (November 28, 2023)

• Translations in traditional and simplified Chinese.

Version 1.8.4 (October 22, 2023)

• Arabic and Hebrew translations.

Version 1.8.3 (October 9, 2023)

• New robot model: mBot!

Version 1.8.2 (October 4, 2023)

• 2D state space coloring is now available in "user code" mode.
• Bug fixes for software updates and AlphaBots robot updates.

Version 1.8.1 (September 27, 2023)

• Improved connection for Thymio robots.

Version 1.8.0 (September 20, 2023)

• New Bluetooth (BLE) protocol for AlphaBots robots, with many improvements :some text
  • Compatibility with macOS.
  • More stable connections (fewer disconnections).
  • Better robot color detection.
• However, the BLE protocol is only available for the latest robot models (numbers from approx. 600 upwards). If you wish to upgrade your robot to take advantage of BLE protocol enhancements, please follow the detailed instructions on this page.
• And there's much more to discover when you use our software!

Version 1.7.22 (August 25, 2023)

• Improved reading of licenses registered by Thymio robots (to avoid repeated requests for activation keys).
• Added requirements-linux.txt file to help with Linux installation.

Version 1.7.21 (June 12, 2023)

• Improved automatic restart of AlphAI robots after an update.
• Bug fixes, especially for the Thymio robot.

Version 1.7.20 (May 24, 2023)

• Improvements and bug fixes for the API.

Version 1.7.19 (May 20, 2023)

• You can request a trial version of the Thymio and Buddy robots.

Version 1.7.18 (April 26, 2023)

• Minor updates are now lighter and therefore quicker to download.

Version 1.7.17 (April 25, 2023)

• Fixed a bug that prevented the program from starting up on Windows computers configured in German.
• On Windows, the simulated AlphAI robot can now make beeps using the computer's sound.

Version 1.7.16 (April 5, 2023)

• Fixed a bug causing disconnections when using the API.

Version 1.7.15 (April 4, 2023)

• Update for the Buddy robot.

Version 1.7.14 (April 3, 2023)

• Fixed a bug when loading certain configurations.

Version 1.7.13

• Custom actions can be created.

Version 1.7.12 (March 20, 2023)

• Fixed a bug causing a disconnection after 15 seconds when using the API.
• Simplified installation on macOS and Linux.

Version 1.7.11

• Possibility of requesting a trial license for 15 days.

Version 1.7.10

• Graphical enhancement of 1D and 2D graphs and highlight maps.
• Improved proxy management for license server access.

Version 1.7.9

• Improved state-space graphs in the "KNN" and "intruder detection" scenarios.

Version 1.7.8

• Improved licensing system for the Thymio robot.

Version 1.7.7

• Bug fixes for macOS users.

Version 1.7.5

• Improved reliability of connections with AlphAI robots.
• Automatic detection of available robots and their color (experimental).
• New teacher mode to protect certain functions with a password (your activation key).

‍

Recurring problems

‍

Visitez notre FAQ !

‍

Présentation du robot AlphAI

Introduction

‍

Learning Robots a conçu un petit robot à l’allure sympathique, mais qui en a sous le capot !

Ce robot a été élaboré spécifiquement pour l’utilisation de la solution AlphAI : son grand nombre de capteurs (notamment la caméra grand angle), sa polyvalence et son format compact permettent de réaliser l’intégralité des activités disponibles sur le logiciel.

Ce robot a été pensé pour être à la fois robuste et démontable à n’importe quel moment. 

Les coques et pare-chocs sont imprimés chez nous ce qui nous laisse une grande marge de liberté quant au design du robot. N'hésitez pas à nous demander les fichiers 3d si vous souhaitez les customiser ! 

‍

Composition

Sensors

Caméra grand angle

Ultra-son

5 capteurs infra-rouge de suivi de ligne

‍

Effectuateurs

2 roues motrices

4 LEDS multi-couleurs

Buzzer

‍

Ordinateur de bord

Raspberry Pi Zero (linux, Python)

Connection WiFi & Bluetooth au PC

‍

Coque

Sympathique, amortissante, démontable, disponible en 8 coloris

1. Sensors

The sensors you can use on the software are :

• La détection d’obstacles : permet d’ajouter une entrée binaire (1 si le robot a essayé de bouger mais n’a pas réussi, 0 dans le cas contraire).
  En mode expert, vous avez accès à deux paramètres supplémentaires :some text
  • seuil de détection de mouvement de la caméra : permet de paramétrer la sensibilité du détecteur d’obstacles. Il faut augmenter la valeur si on a trop de faux positifs (capteur qui détecte un obstacle inexistant), et inversement diminuer la valeur si on a trop de faux négatifs (capteur qui ne détecte pas un obstacle réel).
  • hauteur de blocage de la caméra : permet d’ignorer la partie haute de l’image lors de la détection des blocages. Avec une valeur de 1, l’image entière est analysée, avec une valeur de 0.5, seule la moitié inférieure est analysée.

‍

• Capteurs IR : permet d’utiliser les 5 capteurs infrarouges situés sous le robot. Ils communiquent chacun une valeur entre 0 et 1 en fonction de la luminosité de la surface. Il y a deux modes principaux :some text
  • Détection du noir : la valeur 0 correspond au blanc et la valeur 1 correspond au noir. Recommandé pour suivre une ligne noire sur fond blanc.
  • Reflection detection: value 0 corresponds to black and value 1 corresponds to white.

‍

The binary mode option allows you to obtain only integer values 0 and 1 instead of decimal values between 0 and 1.

When binary mode is active, the IR threshold parameter is used to set the switching threshold between binary values 0 and 1. For example, when the threshold is set to 0.5 (default value), all values between 0.5 and 1 are rounded to 1, and all values between 0 and 0.5 are rounded to 0.

‍

Il y a aussi plusieurs boutons (5 capteurs, capteur central, capteurs intérieurs, capteurs extérieurs) qui permettent de sélectionner quel sous-ensemble des capteurs IR on souhaite activer.

‍

‍

• Ultra-Sons : permet d’utiliser le capteur à ultra-sons situé à l’avant du robot. Il communique une valeur en fonction de la distance captée. Il y a 3 modes d'utilisation :some text
  • distance obstacle : la valeur renvoyée est la distance de l'obstacle   mesurée en mètres.
  • proximité obstacle : la valeur renvoyée est inversement proportionnelle à la distance mesurée.
  • Absence / présence obstacle : le capteur renvoie 1 si un obstacle est détecté et 0 sinon. La distance de détection des obstacles peut être ajustée grâce au curseur en-dessous.

‍

• Caméra :  permet d’activer la caméra à l’avant du robot. Plusieurs options sont proposées, qui déterminent la résolution de la caméra et l'utilisation ou non du zoom.

The camera image pre-calculation button is used to modify the processed values:

• when pre-calculation is deactivated, the image defaults to color (RGB system).
• grayscale mode captures the brightness of each pixel.
• the color mode in the image detects colors. All white/gray/black pixels will obtain the value 0 and colored pixels the value 1.
• green channel mode detects only the presence of green (values close to 1) or its absence (values close to 0).
• red vs. green mode returns a value between -1 and 1 for each pixel, corresponding to the amount of red minus the amount of green.

‍

Le bouton prendre une photo permet de prendre une photo avec la caméra du robot et de l'enregistrer sur votre ordinateur.

‍

‍

• Le bouton dernières actions permet d'activer la mémoire de la dernière action lorsque le robot doit prendre une décision. Cela peut être utile par exemple pour éviter les situations où le robot effectue une action qui annule l'action précédente (il recule après avoir avancé, ou il pivote à droite après avoir pivoté à gauche).
• En mode robot simulé, le capteur état du robot simulé renvoie des informations sur la position, l'orientation et la vitesse du robot simulé.

‍

2. The actions

The actions you can use on the software are :

You can also create a custom action by clicking on the button: 

‍

The following window will then appear: 

‍

Name your action and check "robot action" to modify the parameters: the new action is now available.

‍

To save it for future use, click on File > Save > Save configuration.

‍

3. Operating environment

Nous vous recommandons d’utiliser le robot dans une arène AlphAI.

Acheter une arène (lien boutique)

‍

Pour réaliser l’intégralité des activités sur le logiciel, le robot aura besoin de :

• Une surface très plane et propre, de couleur unie
• Des murs extérieurs et intérieurs de couleurs différentes (et différente du sol), d’une hauteur supérieure au robot
• D’une ou plusieurs lignes au sol d’une couleur très contrastée avec la bâche  (utilisez par exemple un scotch noir ; il est fourni avec les arènes.)

Si vous ne disposez pas d’arène ou même de robot, sachez également que de nombreuses activités sont réalisables avec le robot AlphAI simulé en 2D dans le logiciel.

Robot connection

En Wifi (recommandé)

Video - alphai - preparation 1

‍

Nous vous conseillons de toujours privilégier une connexion en WiFi si cela est possible, car elle permet de communiquer avec le robot avec un meilleur débit. De plus, elle est obligatoire pour la mise à jour des robots.

1. Regardez le numéro inscrit au marqueur sous votre robot, en prenant garde à le tenir par sa base et non sa coque, puis allumez le robot en actionnant l'interrupteur PWR SWITCH sur ON
2. Posez le robot dans l’arène et patientez quelques instants, jusqu’à ce que le robot vibre et clignote.
3. Ouvrez le panneau de connexion WiFi de votre ordinateur : le robot apparaîtra alors sous le nom “ALPHAI-00XXXX” (XXXX étant le nombre que vous avez relevé sous le robot). Connectez-vous au robot : le mot de passe est la copie exacte du nom du réseau WiFi (ALPHAI-00XXXX).
4. Lancez le logiciel AlphAI. Vérifiez en haut à droite de l’écran d’accueil que vous avez choisi le modèle de robot AlphAI
5. Le robot avec son numéro et une icône Wifi apparaît alors sur l’écran de connexion : cliquez dessus
6. Le robot vibre, ses lumières s’allument en continu et l’interface du logiciel s’ouvre. C’est parti !

⚠️  Avant d’éteindre votre robot ou de changer ses piles, nous vous conseillons d’appuyer sur le bouton “déconnexion” en bas à droite de l’écran dans l’interface.

‍

TROUBLESHOOTING

‍

En Bluetooth

Video - alpha - preparation 2

Si vous préférez connecter le robot à votre ordinateur en bluetooth, sachez que le débit de transmission est plus faible qu’avec le WiFi. De plus, quand le robot aura besoin d’être mis à jour, il faudra utiliser la connexion en WiFi.

‍

1. Regardez le numéro inscrit au marqueur sous votre robot, en prenant garde à le tenir par sa base et non sa coque, puis allumez le robot en actionnant l'interrupteur PWR SWITCH sur ON
2. Posez le robot dans l’arène et patientez quelques instants, jusqu’à ce que le robot vibre et clignote.
3. Dans les paramètres de votre ordinateur, vérifiez que le bluetooth est bien activé
4. Lancez le logiciel AlphAI. Vérifiez en haut à droite de l’écran d’accueil que vous avez choisi le modèle de robot AlphAI
5. Veillez à ce que le bouton “Bluetooth Low Energy” en haut à droite de votre écran soit bien activé (avec un fond jaune).
6. Le robot avec son numéro et une icône Bluetooth apparaît alors sur l’écran de connexion : cliquez dessus
7. Le robot vibre, ses lumières s’allument en continu et l’interface du logiciel s’ouvre

⚠️  Avant d’éteindre votre robot ou de changer ses piles, nous vous conseillons d’appuyer sur le bouton “déconnexion” en bas à droite de l’écran dans l’interface.

Votre robot n’apparaît pas ? → désactivation BLE

TROUBLESHOOTING

‍

En simulation

Video - alpha - preparation 3

Si vous n’avez pas de robot AlphAI, vous pouvez tout de même utiliser notre logiciel grâce au simulateur 2D : 

‍

1. Launch AlphAI software
2. Vérifiez en haut de l’écran que vous avez choisi le modèle de robot AlphAI dans le logiciel.
3. Cliquez sur “Simulateur 2D”
4. Le logiciel s’ouvre : observez en bas à gauche de l’écran un petit robot simulé dans une arène en 2D !
5. L’arène virtuelle peut être customisée en changeant les couleurs des murs extérieurs et intérieurs ainsi qu’en supprimant ce mur. Pour y accéder, Paramètres → Affichage des paramètres → ExpertCapteurs → bas de la page

Robot maintenance

Remplacement des piles

Video - alpha - preparation 4

Le robot utilise des piles rechargeables en lithium-ion qui sont donc très puissantes mais se déchargent rapidement. C’est pourquoi nous vous conseillons de toujours garder les piles de rechange fournies chargées à proximité.

‍

Si les piles du robot sont sur le point d’être à plat, une icône de batterie rouge apparaîtra sur votre écran en bas à gauche. Changez les piles en moins d’une minute : 

1. Appuyez sur le bouton “déconnexion” en bas à droite de l’écran. Vous allez atterrir sur l’écran d’accueil
2. Soulevez le robot en prenant garde à le tenir par sa base et non sa coque, puis éteignez le en mettant l'interrupteur PWR SWITCH sur OFF
3. Retirez la coque du robot en exerçant une pression délicate sur sa base, puis en la faisant pivoter vers l’avant pour dégager la caméra
4. Les piles se trouvent à l’arrière : glissez le doigt pour les remplacer avec des piles chargées en veillant à bien respecter les signes + et -
5. Nous vous conseillons de mettre immédiatement les piles vides à recharger sur le chargeur AC fourni
6. Remettre la coque sur le robot en commençant par l’avant ; veillez à bien positionner la caméra dans son emplacement, puis vérifiez que toute la base de la coque est insérée dans le châssis du robot. Appuyer délicatement sur l'arrière de la coque : vous devriez entendre un petit “clic”
7. Rallumez le robot, reconnectez-le et reprenez votre activité !

‍

Nous vous conseillons de toujours mettre à charger les piles utilisées pendant les activités en fin de session.

‍

Mises à jour du robot

‍

Learning Robots travaille continuellement à développer le logiciel et le robot AlphAI et à améliorer l’expérience utilisateur. C’est la raison pour laquelle nous procédons de temps en temps à des mises à jour, qui seront transmises automatiquement à la Rapsberry Pi du robot lors de la prochaine connexion en WiFi.

Link to FAQ updates

‍

Recurring problems

‍

Votre robot ne s’allume plus ? Impossible de vous connecter au logiciel ? Les roues de votre robot sont bloquées ? …

Trouvez la réponse à votre problème sur cette page : 

Lien vers FAQ robot AlphAI

‍

Support & garantie

‍

Les robots AlphAI sont garantis jusqu’à 2 ans après la date d’achat pour tout malfonctionnement.

En cas d'utilisation intensive, il est normal que les moteurs puissent présenter de l'usure : nous proposons des kits de remplacement de moteur (lien vers boutique). N'hésitez pas à nous contacter si vous souhaitez que nous nous chargions du remplacement.

‍

L’équipe de Learning Robots reste à votre disposition. Si vous ne trouvez pas comment résoudre votre problème sur notre page FAQ, n’hésitez pas à nous contacter par email : support@learningrobots.ai

‍

Arène AlphAI

‍

Afin de faire évoluer le robot dans un environnement parfaitement adapté, Learning Robots a conçu un système d’arènes modulaires très facile à assembler et à transporter.

‍

Les arènes sont disponibles dans 4 tailles différentes qui sont combinables selon vos besoins et le nombre de robots.

‍

Elles sont constituées de planches en bois peintes, de bâches et de supports.

Elles sont fabriquées en pin du Jura par Olivier Sauge (artisans-du-bois.com) en France.

‍

Composition

• bâche(s) à poser sur le sol, avec design imprimé ou non, sur une surface parfaitement plane. Assemblez les bâches grâce au scotch de peintre (inclus) pour augmenter la surface de l’arène !
  
  
• planches rouges, qui constituent les murs extérieurs de l’arène, à assembler grâce à leurs encoches et aux supports
  
  
• planches noires, qui constituent les murs intérieurs de l’arène, à assembler grâce à leurs encoches et aux supports. Maintenez les planches noires aux planches rouges grâce aux bannières de course.
  
  
• bannière(s) de course, qui permettent de joindre les murs intérieurs et extérieurs, tout en créant un départ de course pour vos robots ! Elles sont fournies avec des réhausseurs
  
  
• Supports :
  • Pieds : à utiliser dans les angles sous les encoches (planches qui s'emboîtent) ou aux extrémités. Il n'est pas nécessaire d'en mettre sur le dessus.
  • Connecteurs : à utiliser pour assembler des planches en ligne droite. Il est conseillé d'en mettre à la fois sous et au-dessus des connexions. Ils peuvent être utilisés parallèlement mais aussi perpendiculairement aux planches, en fonction de la disposition souhaitée.

‍

Video - alpha - preparation 5

Le montage

1. Commencez par poser les bâches au sol, sur une surface très plane, et maintenez-les ensemble grâce au scotch de peintre pour plus de stabilité
2. Assemblez les murs extérieurs grâce aux encoches et aux supports (seulement en dessous pour les pieds)
3. Positionner le(s) mur(s) intérieur(s) au centre de l’arène avec leurs supports pieds
4. Reliez les murs intérieurs et extérieurs grâce à la ou les bannière(s) de course, en veillant à bien surélever celle(s)-ci avec les réhausseurs fournis.

‍

Les arènes sont modulables à votre guise ! Voici quelques exemples de dispositions :

‍

⚠️  Si vous avez une planche noire simple au centre de l'arène (et qui ne peut pas être maintenue aux planches rouges extérieures grâce à la bannière de course), nous vous conseillons de doubler cette planche en utilisant des connecteurs afin d'avoir plus de stabilité.

‍

Utilisation scotch

Grâce au scotch noir fourni avec votre arène, vous pouvez tracer au sol des lignes à suivre par votre robot ! Elles sont très facilement décollables de la bâche à la fin de l’activité.
Video - alpha - preparation 6

Le tracé le plus courant est une forme de 8, mais n’hésitez pas à faire parler votre imagination ! Préconisez des courbes douces afin de ne pas perturber le robot.

Course de robots autonomes

Activité ludique pour une arène avec plusieurs robots : les élèves entraînent les robots à rouler dans un circuit puis une course est organisée. Les élèves apprennent par la manipulation le principe de l'apprentissage supervisé et l'importance de la qualité des données d'entraînement.

La course de robots est l’activité recommandée pour débuter la solution AlphAI.

Contenu vidéo

Introduction

Construisez votre arène de manière à former un circuit. Nous vous recommandons d’utiliser une arène de course conçue par Learning Robots, mais vous pouvez également construire votre propre circuit : veillez dans ce cas à ce qu’il y ait un bon contraste visuel entre le sol et les bords du circuit, ainsi qu’un éclairage uniforme. Vérifiez également que le sol est propre.

Paramétrage

Connectez tous les robots à un ordinateur, puis choisissez le configuration d'exemple “course de robots” ou créez vos propres paramètres.

Veillez à vérifier que tous les robots ont les mêmes paramètres et surtout la même vitesse.

‍

Entraînement

Vérifiez que le bouton « autonome » est bien désactivé, et que le bouton “apprentissage” est bien activé.

C’est à vous de jouer ! Chacun entraîne son robot à se déplacer en cliquant sur les actions à droite de l’écran ou en le contrôlant avec les flèches directionnelles ou AZEQSD du clavier.
Nous vous conseillons de faire des tours d’arène dans le sens des aiguilles d’une montre.

Pendant cette phase d’apprentissage, ce n’est pas la peine de chercher à aller vite : le but est surtout d’apprendre au robot à faire des tours dans le bon sens et sans se cogner aux murs. Prenez le temps de bien choisir l’action adéquate à chaque fois (si vous vous trompez, cliquez sur “Oublier action” à côté du bouton apprentissage). Faites attention à ne pas confondre la gauche et la droite quand le robot est en sens inverse !

Apprenez au robot à rester loin de l’obstacle central pour éviter qu’il s’y coince lorsqu’il sera autonome.

Vous pouvez également déplacer le robot à la main pour le mettre intentionnellement face à des obstacles et lui apprendre quoi faire dans ces situations.

Dans le panneau de contrôle en bas de l’écran, vous pouvez fixer la vitesse de pointe du robot. Nous vous conseillons une vitesse maximale de 30 pour une arène petite course, 35 pour une arène grande course, et 40 pour une arène très grande course.

Plus vous augmentez la vitesse, plus le robot sera rapide, mais plus il sera difficile à contrôler. Choisir une vitesse très élevée n’est pas toujours un avantage !

Test de l’apprentissage et améliorations

Après avoir fait quelques tours de l’arène, vous pouvez activer l’autonomie. Si votre robot est bien entraîné, il se mettra alors à faire des tours par lui-même !

Mais l’apprentissage n’est pas terminé ; même lorsque le robot se pilote lui-même, vous pouvez continuer de le commander en appuyant sur les flèches pendant qu’il se déplace. Par exemple, si le robot se coince contre un mur et ne sait plus quoi faire, vous pouvez le débloquer en lui demandant de faire marche arrière.

‍

La course de robots

Une fois vos robots entraînés, organisez une compétition : placez les robots concurrents sur la ligne de départ. Donnez le top départ et les équipes cliquent alors en même temps sur le bouton « Autonome » (ou appuient sur la barre d’espace) pour démarrer la course.

Pendant la course, seul le mode autonome est autorisé : les participants ne doivent pas donner d’instruction à leur robot. Un arbitre pourra déplacer les robots qui sont bloqués pendant plus de 5 secondes, pour leur permettre de continuer la course.

Le premier robot qui a effectué 3 tours complets a gagné !

‍

Retours d'expérience et conclusion

Nous avons utilisé ici un algorithme d’apprentissage supervisé. Cet algorithme est basé sur le réseau de neurones artificiels qui est affiché à l’écran (mais il existe d’autres types d’algorithmes qui ne sont pas basés sur des réseaux de neurones, par exemple l’algorithme des K plus proches voisins). Tous les algorithmes d’apprentissage supervisé fonctionnent de la manière suivante :

Dans une première phase appelée entraînement, nous avons fourni des exemples de décisions à l’algorithme, c’est-à-dire à la fois des images de ce que voit la caméra du robot et les actions qu’il faut choisir lorsque la caméra voit ces images. Pendant l’entraînement, le réseau de neurones artificiels a été modifié par l’algorithme d’apprentissage (plus spécifiquement, certaines connexions ont été renforcées, d’autres diminuées, de sorte que le réseau de neurones devienne capable d’imiter les mêmes prises de décision).

Dans un second temps appelé utilisation, l’algorithme est capable de prendre de bonnes décisions sur de nouvelles images.

Nous avons vu que tous les robots n’ont pas appris la même chose, certains se sont mieux comportés pendant la course, d’autres moins bien. Comme tous les participants ont utilisé le même algorithme, nous voyons bien que la qualité des prises de décisions en autonomie dépend de la qualité des données d’entraînement.

Nous pouvons discuter ensemble de ce qui fait la qualité des données d’entraînement :

• Qualité des données d’entraînement = absence d’erreurs dans les prises de décisions

• Quantité des données pas toujours gage de qualité d’autonomie

• Exhaustivité des situations : le robot a plus de risques de faire un mauvais choix lorsqu’il est confronté à une situation inconnue

‍

Pour aller plus loin

Maintenant que les élèves ont compris que pour gagner la course, le plus important est la qualité des données d'entraînement, recommencer l'activité depuis le début !

Vous pouvez également recommencer la course en ajoutant de nouvelles règles :

• Limiter les données d’entraînement (par exemple : 25 points de données maximum), mais en laissant la possibilité aux participants de déplacer leur robot à la main.
• Complexifier l’arène
• Avoir une arène différente pour l’entraînement et pour la course

‍

Suivi de ligne

Cette activité est réalisée avec chaque robot individuellement. Nous allons apprendre au robot à suivre un tracé au sol, sans qu’il ne se trompe !

Les élèves apprennent que le succès de l'apprentissage supervisé dépend plus de la qualité et de l’exhaustivité des données d’entraînement du robot que de leur quantité. Ils pourront comprendre très facilement le principe du réseau de neurones, car celui utilisé dans cette activité est très simple et lisible (5 entrées, 5 ou 6 sorties)

Contenu vidéo

Introduction

Sur une surface plane de couleur unie et claire, tracez un parcours grâce à un scotch de couleur sombre (fourni avec les arènes).

‍

= Video - alpha - preparation 6
Si vous souhaitez utiliser votre propre matériel, veillez à ce que le robot perçoive bien le contraste entre le sol et la ligne.

La forme classique est un “8”, mais n’hésitez pas à faire parler votre imagination !
Veillez cependant à toujours créer des courbes douces pour ne pas perturber le robot.

‍

Paramétrage (connexion)

Connectez le robot à un ordinateur, puis choisissez le configuration d'exemple “suivi de ligne” en édition manuelle ou en apprentissage supervisé, ou bien créez vos propres paramètres.

Veillez à vérifier que le robot a une vitesse inférieure ou égale à 20 à l’aide du curseur au bas de vôtre écran.

Entraînement

Si vous êtes en édition manuelle : 

Vérifiez que les boutons « autonome » et “apprentissage” sont désactivés, et que le bouton “édition manuelle” est bien activé.

Cliquez sur les liens entre les neurones d’entrée (capteurs infrarouges) et de sortie (action du robot) pour créer une connexion. Nous vous conseillons de créer les connexions suivantes : 

• Capteur IR gauche : pivoter à gauche
• Capteur IR centre gauche : tourner à gauche
• Capteur IR central : aller tout droit
• Capteur IR centre droit : tourner à droite
• Capteur IR droite : pivoter à droite

Voici alors à quoi devrait ressembler votre réseau de neurones : 

Si vous êtes en apprentissage supervisé : 

Vérifiez que le bouton « autonome » est bien décoché, et que le bouton “apprentissage” est bien coché.

Placez le robot sur la ligne tracée sur le sol pour activer les capteurs. A chaque fois qu’un des capteurs est activé, déclenchez l’action correspondante : 

• Capteur IR gauche : pivoter à gauche
• Capteur IR centre gauche : tourner à gauche
• Capteur IR central : aller tout droit
• Capteur IR centre droit : tourner à droite
• Capteur IR droite : pivoter à droite
• Aucun capteur : reculer

Nous vous conseillons de donner plusieurs exemples pour chaque situation.

‍

Test de l’apprentissage

Une fois que le réseau de neurones est configuré, observons si le robot réussit à suivre la ligne !

Placez-le en début de parcours, activez l’autonomie et regardez comme il se débrouille. 

Vous pouvez ensuite complexifier la piste en y ajoutant des intersections afin de créer de nouvelles difficultés pour les robots !

Review and feedback

Grâce à un réseau de neurones très simple et très peu de données d’entraînement, le robot a réussi à suivre la ligne.

On peut observer sur le logiciel le poids accordé à chaque connexion, et comprendre la manière dont le robot prend ses décisions : en fonction du capteur qui est activé (ou non), l’algorithme attribue des préférences à chacune des actions à choisir : le robot sélectionne l’action avec la préférence la plus forte.

Votre robot est sorti de piste ou a choisi la mauvaise action ? Essayez de comprendre pourquoi ! Quelques suggestions :

• il y a un biais : vous avez fait une erreur dans l’entraînement du robot
• plusieurs capteurs se sont activés en même temps, par exemple à un croisement : le robot a-t-il été entraîné à réagir à cette situation ?
• l’angle d’une courbe de la ligne au sol est trop abrupt
• la vitesse du robot est trop forte

Robot suiveur

Les élèves pourront apprendre au robot à suivre leur main ou un objet bien identifiable.

On pourra aller plus loin en laissant place à l'imagination des élèves : réalisation de parcours ou chorégraphies, où le robot réagit à divers signes visuels, comme par exemple des signes de la main.

‍Contenu vidéo

Introduction

Placez le robot sur une table avec assez d’espace pour se déplacer. Vous pouvez utiliser une arène si vous voulez éviter que le robot tombe de la table. Dans ce cas, une petite arène sans obstacle sera suffisante.

Paramétrage

Connectez le robot à l’ordinateur, puis choisissez le configuration d'exemple “navigation avec caméra”.

Nous utiliserons le capteur caméra, et les actions suivantes : avancer, pivoter à droite, pivoter à gauche, et s’arrêter.

Veillez à adapter la vitesse à la taille de la table.

‍‍

Entraînement et mise en oeuvre (phase d’apprentissage)

L'entraînement se fera à 2, en faisant attention à être bien coordonné.
Un des élèves s’occupera de faire les signes de la main au robot, pendant que l’autre va gérer le logiciel.

L’objectif est d’apprendre au robot à suivre la main de l’élève (ou un objet bien identifiable).

Dans une première phase, un des élèves place sa main dans le champ de vision caméra du robot, pendant que l’autre choisit l’action qui rapprochera le robot au plus près de la main. Donnez plusieurs exemples au robot pour chaque position de la main dans l’image.

Dans une deuxième phase, il faudra apprendre au robot à s’arrêter lorsqu’il ne voit pas de main. De nouveau, le robot a besoin de plusieurs exemples avec des points de vue différents : l’élève en charge du logiciel clique sur l’action “s’arrêter”, pendant que l’autre élève place le robot à différents endroits (en faisant attention à ne rien mettre devant la caméra évidemment !)

‍

Test de l’apprentissage et améliorations

Activez maintenant le mode Autonome.

Vérifiez que le robot a bien appris en observant s'il suit correctement votre main.
Si ce n'est pas le cas, désactivez à nouveau le mode autonome et ré-entraînez le robot.

‍

Des pistes pour aller plus loin

‍

• On inverse les rôles, le robot parvient-il à suivre la main de l’autre élève ou un objet différent ? Si non : poursuivre l’entraînement jusqu’à ce que le robot soit capable de suivre les mains des deux élèves.
• Placez le robot sur un parcours (tracez par exemple 2 lignes parallèles sur le sol), le mettre en mode autonome et le guider à la main sur le parcours. Permet d’évaluer à la fois l’entraînement du robot et le guidage effectué par l’élève.
• Entraînez un robot à en suivre un autre ! Le robot de devant sera piloté, et l’autre devra le suivre en mode autonome. Astuce : pensez à choisir une vitesse un peu plus faible pour le robot suiveur.
• Visualiser les données d’apprentissage et corriger les erreurs qui s’y trouvent. Le comportement du robot s'en trouvera amélioré.

‍

Review and feedback

La mission des élèves était de réaliser l’entraînement (apprentissage supervisé) d’une IA.

Après apprentissage, le robot est capable d'interagir avec un utilisateur en réagissant aux signes de sa main.

En montrant des exemples au robot, il parvient à associer correctement les bonnes actions aux signes de main correspondants ce qui permet de « communiquer » avec lui.

‍

Notions à retenir:

• Ce sont les données d’entraînement qui déterminent le comportement du robot.
• La qualité des données (absence d’erreurs) est très importante.
• Il faut aussi fournir au robot des exemples suffisamment divers si l’on souhaite qu’il soit capable de généraliser le comportement suivi (par exemple suivre un autre objet ou une main différente).

Algorithme KNN

Visualisation et application de l'algorithme des K plus proches voisins (au programme de première NSI) pour apprendre au robot à éviter les obstacles.

Niveau expert : dans l’activité “Algorithme KNN avancé”, les élèves pourront reprogrammer l'algorithme par eux-mêmes et le mettre en œuvre sur le robot.

Contenu vidéo

Introduction

Placez le robot dans une arène sans mur intérieur. Veillez à ce que l’arène soit bien éclairée, afin d’avoir un fort contraste entre le sol et les murs.

Paramétrage

Connectez le robot à l’ordinateur puis choisissez la configuration d'exemple “KNN caméra”.
Veillez à ce que la vitesse du robot soit inférieure ou égale à 30.

Pour cette activité, le robot analyse des images caméra dont la résolution a été réduite à 2 pixels seulement, et sans couleur. On obtient donc un pixel gauche et un pixel droit, qui mesurent des niveaux de gris. L'abscisse (pixel de gauche) et l’ordonnée (pixel de droite) du graphe montrent ces valeurs de niveaux de gris, 0 correspondant au noir et 1 correspondant au blanc.

Les actions par défaut sont : avancer (en jaune), pivoter à gauche (en rose) et pivoter à droite (en vert).

Il est possible d’ajouter davantage d’actions pour ce scénario, mais veillez à le faire dès le début, car modifier les actions provoque l’effacement de la mémoire d'expérience.

Phase d'entraînement

Vérifiez que le bouton « autonome » est bien décoché, et que le bouton “apprentissage” est bien coché.

Dirigez le robot en cliquant sur les flèches à droite de l’écran, où grâce aux touches « flèches » du clavier.

Tournez quand le robot est proche des murs et allez tout droit sinon. Vous pouvez aussi déplacer le robot à la main pour le mettre dans chaque situation.

Après chaque mouvement, un nouveau point apparaît. La position de chaque point est déterminée par ses coordonnées (x ; y), l’abscisse x représentant la luminosité dans la zone de gauche et l’ordonnée y la luminosité dans la zone de droite. La couleur autour de chaque point est la couleur associée à l’action choisie (vert pour pivoter à droite, jaune pour en avant et rouge pour pivoter à gauche).

Ces points sont les données d’entraînement. Cette phase est primordiale pour que l’IA fonctionne correctement. Si les données d’entraînement contiennent trop d’erreurs ou approximations, l’IA ne permettra pas d’avoir un résultat satisfaisant.

‍

Une fois l’entraînement terminé, ouvrez le panneau Visualisation et cochez la case “arrière-plan” la section “Espace d’états”.

Vous verrez alors apparaître à l’écran les 3 différentes zones de couleurs qui correspondent à l’action que choisira le robot en fonction de la luminosité captée par sa caméra.

Si votre robot a été bien entraîné, le graphe devrait ressembler à : 

La luminosité diminue lorsque le robot s’approche des murs. Normalement, si la zone de gauche est la plus sombre, il faut tourner à droite, et inversement.

Lorsque vous aurez trois régions bien claires sur le graphique, arrêtez la phase d’entraînement et activez l’autonomie pour passer à la phase de test.

‍

Test de l’apprentissage et améliorations

Activez l’autonomie en cliquant sur le bouton correspondant à l’écran ou en appuyant sur la barre d’espace.

Comment se comporte le robot ? Évite-t-il les obstacles comme prévu ?
Si le robot est bien entraîné, il saura éviter les bords par lui-même. Si au contraire il est mal entraîné ou la luminosité dans l’arène n’est pas homogène, les zones de couleur sur le graphique auront des contours plus irréguliers et le robot fera plus d’actions inappropriées.

Comprendre la prise de décision de l’algorithme : le point le plus gros est celui capté à cet instant par la caméra : il se lie au point le plus proche dans le graphe, qui a été enregistré lors de la phase d'entraînement : c’est l’action correspondante à son plus proche voisin qu’il va choisir d’effectuer !

‍

Pistes pour aller plus loin

• Dans l’onglet IA, faire varier la valeur de k (le nombre de voisins). Observer l’effet sur la prise de décision et sur la coloration d’arrière-plan du graphe. Quelle valeur de k donne le meilleur comportement ? Pourquoi ?
• Après avoir bien compris le principe de l’apprentissage, refaire un apprentissage avec un plus petit nombre de points (par exemple: défi 5 points d’entraînement seulement).

‍

Review and feedback

Points abordés / Notions à retenir :

• Le principe de l’algorithme des k plus proches voisins : comprendre et savoir expliquer comment sont prises les décisions du robot.
• Quel est l’impact des données d'entraînement sur le résultat ? Comment bien choisir les données d’entraînement ?
• Quel est l’impact du paramètre k ? Comment choisir la meilleure valeur pour ce paramètre ?

Détection d’intrus

Compréhension mathématique des réseaux de neurones à travers une activité basée sur le capteur à ultrasons du robot. On y découvre notamment pourquoi on a besoin de couches de neurones intermédiaires.

Contenu vidéo

Mise en place

Placez le robot à côté de l’ordinateur, face à un mur (ou une planche d’arène) à environ 50 cm, et munissez-vous d’un objet à côté plat (une boîte, une planche, un smartphone) qui jouera le rôle de l’intrus.

Chargez la configuration ‘Détection d’intrus’. Ce scénario utilise uniquement le capteur à ultrasons.

Toute l’activité est réalisée en mode ‘édition manuelle’, c'est-à-dire que l’on va choisir soi-même les paramètres du réseau de neurones sans faire appel à un algorithme d’apprentissage.

‍

Présentation de l’interface

Dans cette activité, votre écran principal comporte deux visualisations :

• En bas, le réseau de neurones étudié. Au début de l'activité, le mode édition manuelle doit être activé, ce qui permet de modifier soi-même les paramètres du réseau de neurones. Pour modifier la valeur d'une connexion, placez votre souris sur cette connexion (elle devient rouge), puis utilisez votre clavier pour entrer la valeur souhaitée ou la molette de votre souris pour modifier la valeur actuelle. Pour modifier la valeur du biais d'un neurone, placez votre souris sur le neurone lui-même (pas l'affichage de la valeur), puis procédez comme pour les connexions.
• En haut, un graphique représentant l'espace d'états. En abscisse, la distance mesurée par le capteur à ultrasons. En ordonnée, les niveaux d'activation des neurones de sortie. Il y a deux courbes représentées car il y a deux neurones de sortie. La correspondance courbe/neurone est indiquée par un code couleur. La valeur des neurones de sortie est une fonction de la valeur d'entrée (la distance). La couleur de fond du graphique indique quelle courbe est au-dessus de l'autre pour chaque valeur d'entrée, et donc quelle action sera choisie par le robot pour cette valeur d'entrée.

‍‍

Objectif et problématique

Le robot est face à un mur et doit biper lorsque quelqu’un (un intrus) passe entre lui et le mur.

Il faut configurer le réseau de neurones pour accomplir cette tâche. Puisque le seul capteur utilisé est le capteur à ultrasons, l’objectif est d’obtenir un bip lorsque la distance est faible, et l’action ‘ne rien faire’, lorsque la distance est normale.

Intégration de biais neuronaux

Les simples paramètres ‘poids des connexions‘ sont insuffisants pour accomplir cette tâche. Il faut activer l’option ‘biais neuronal’ (dans l’onglet IA), cela débloque de nouveaux paramètres qui vont nous permettre d’atteindre cet objectif.

Tentative de triche

Problématique

Un intrus tente de tricher en exploitant les caractéristiques du capteur à ultrasons : si le côté plat est placé en diagonale par rapport au capteur, les ondes rebondissent et la distance captée est alors bien supérieure à celle du mur ! Il faut adapter notre réseau de neurones pour détecter également cette tentative de triche.

Couches de neurones intermédiaires

Pour cela, nous aurons besoin d’ajouter une couche intermédiaire à notre réseau de neurones (dans l'onglet IA), afin d’obtenir un modèle non-linéaire grâce aux fonctions d’activation.

‍

‍

Review and feedback

Je retiens :

• Un réseau de neurones est un ensemble de neurones organisé par couches. Chaque couche peut comporter un ou plusieurs neurones.
• Les neurones sont des objets abstraits contenant une simple valeur numérique.
• Les neurones sont reliés entre eux par des connexions dont les valeurs sont appelées poids.
• Chaque neurone possède également un biais qui est ajouté à la valeur du neurone.
• Les valeurs de neurones de la couche d’entrée sont déterminées par les valeurs des capteurs.
• Les neurones de la couche de sortie correspondent aux actions du robot. En mode autonome, c’est toujours l’action avec la valeur la plus élevée qui est sélectionnée.
• Les couches intermédiaires permettent au réseau d’accomplir des tâches plus complexes. On voit sur le graphique que les droites des neurones de sortie sont remplacées par des courbes de plus en plus complexes lorsqu’on augmente le nombre de couches intermédiaires.
• Entraîner un réseau de neurones consiste simplement à choisir une valeur pour chacun de ses paramètres : poids des connexions et biais des neurones. Lorsque le nombre de neurones et de connexions devient important, cette tâche complexe est réalisée par un algorithme d’apprentissage !

‍

Évitement d’obstacles

Cette activité consiste à observer un robot qui apprend de manière autonome selon le principe de l’apprentissage par renforcement. On peut en tirer des conclusions assez générales sur les conditions nécessaires pour un apprentissage efficace.

Contenu vidéo

Introduction

Dans cette activité, on n’entraîne pas le robot : c’est le robot lui-même qui va créer les exemples sur lesquels se baser afin de prendre les bonnes décisions d’actions à effectuer.
Pour que le robot soit capable de distinguer les bonnes des mauvaises décisions, l’algorithme comporte un système de récompenses.

Ici, le robot reçoit en fonction des actions effectuées les récompenses suivantes : 

• avancer : 100 points
• tourner : 82 points
• reculer : -50 points
• Le robot reçoit également une pénalité de -50 points lorsqu’il se bloque

Dans la barre “Niveau”, vous pourrez observer la note moyenne de récompenses obtenues par le robot. Son but est de maximiser ce score ; il va donc peu à peu apprendre à choisir les actions qui lui apporteront les récompenses optimales, en prenant en compte ce que ses capteurs lui indiquent

Nous allons donc pouvoir observer les progrès du robot au cours de son apprentissage. Commencez par monter une arène sans obstacle, et placez-y le robot.

‍

Apprentissage du robot en autonomie

Dans le logiciel AlphAI, choisissez la configuration d'exemple : “Apprentissage par renforcement - évitement d’obstacles”.

Dans cette activité, c’est le robot qui apprend tout seul !

Lancez le mode autonome, et observez votre robot. Comment se comporte-t-il ?
Quand le robot a identifié une action qui lui rapporte une récompense (par exemple tourner), il se peut qu’il décide dorénavant d’effectuer uniquement cette action.

Nous allons maintenant activer le bouton “exploration” : de temps en temps, le robot va alors décider d’effectuer une action aléatoire. Il pourra ainsi découvrir que l’action qu’il aurait choisie n’est peut-être pas celle qui correspond à la récompense optimale possible, et ainsi enrichir son apprentissage avec de nouvelles données.

Normalement il apprend successivement à aller tout droit, à se retourner quand il se cogne à un obstacle, puis à reconnaître ces obstacles à l’avance et donc à tourner avant de se cogner dedans ! Cet apprentissage prend à peu près 10 minutes.

N’hésitez pas à désactiver le mode “exploration” lorsque le robot commence à majoritairement choisir les bonnes actions à effectuer.

‍

Review and feedback

Une fois l’apprentissage terminé, arrêtez votre robot et cliquez sur “graphes” dans la barre inférieure (si le bouton n’apparaît pas, changez l’affichage des paramètres en “avancé” ou “expert”). Vous pourrez alors observer dans le graphe du bas l’évolution des erreurs effectuées par le robot : normalement, les valeurs devraient être très hautes en début d’activité, puis peu à peu tendre vers zéro : le robot s’est entraîné tout seul à ne plus faire d’erreurs !

Le fonctionnement de l’apprentissage par renforcement peut être résumé de cette manière : 

‍

Ce qui est nécessaire à l’apprentissage du robot :

• La répétition d’une même tâche : le robot ne parvient pas tout de suite à trouver la bonne solution, ce n’est qu’à force de répétitions qu’il s’améliore.
• L’exploration : le robot doit parfois tester de nouvelles idées, pour ne pas rester enfermé dans une solution non optimale.
• Les récompenses ou pénalités : le robot a besoin d’une aide extérieure pour évaluer si ses décisions sont optimales ou non.
• La place de l’erreur : le robot apprend de ses erreurs sans se décourager ! Les erreurs lui permettent d’apprendre quelles actions ne pas répéter !

Bloqué VS Mouvement

‍

L’objectif de cette activité est de comprendre le fonctionnement de l’algorithme du Q-learning.

‍

Le Q-learning est un algorithme d’apprentissage par renforcement. Le robot va donc apprendre par essais et erreurs, sur la base de récompenses qui sont déterminées par l’utilisateur (comme dans le scénario “Évitement d’obstacles”).

Grâce à cette méthode, nous allons entraîner un robot AlphAI à se déplacer dans une arène sans rester bloqué contre les parois. Cette tâche simple nous permettra de bien comprendre les mécanismes qui interviennent au niveau du réseau de neurones.

Contenu vidéo

‍

Mise en place

Placez le robot dans une petite arène sans obstacle. 

‍

Récompense et édition manuelle

Dans une première partie, on découvre le principe des récompenses, et on utilise le mode “édition manuelle” pour trouver le comportement du robot qui maximise les récompenses reçues.

Reinforcement learning

Dans une seconde partie, on observe l’apprentissage du robot pas à pas et l’évolution des poids des connexions dans le réseau. On découvre l’importance de l’exploration dans l’apprentissage.

Q-learning

Ensuite, il s’agit de découvrir l’algorithme du Q-learning à proprement parler. Il consiste principalement en une formule de mise à jour des poids des connexions après chaque essai du robot. Cette formule fait intervenir deux paramètres dont l’utilité est discutée.

On découvre l’impact de la temporalité sur l’apprentissage : il faut apprendre suffisamment vite sans ‘sauter sur une conclusion’. L’algorithme doit également être capable de prendre en compte les récompenses futures et pas seulement la récompense immédiate : il doit développer une vision à plus long terme.

Deep Q-learning

Le deep Q-learning est une évolution de l’algorithme du Q-learning pour l’appliquer à des réseaux de neurones plus complexes (multi-couches). c’est cet algorithme qui est par exemple utilisé dans le scénario “Évitement d’obstacles”.

AlphAI télécommandé

Dans cette activité de programmation Python, les élèves apprennent à envoyer des commandes au robot en fonction des touches enfoncées au clavier, puis à organiser une course de robots.

Contenu vidéo

Prise en main du robot

Le module alphai.py permet d’envoyer au robot des instructions écrites en python.

Pour que le module fonctionne, le logiciel « AlphAI » doit être lancé. Vous pouvez vous connecter à un robot AlphAI (ou à sa version simulée).

Dans votre éditeur Python favori, créez un nouveau projet à l’emplacement de votre choix et configurez l’environnement Python pour qu’il contienne le module alphai en tapant dans la console IPython ou un terminal :

pip install alphai-api

Cette commande va télécharger et installer le module et ses dépendances.

Ouvrez un nouveau document python ou redémarrez la console, recopiez-y puis exécutez le code suivant :

from alphai import *

motor(30, -30, 5)

‍

Si la première ligne du programme cause une erreur, c’est que la librairie alphai n’a pas été installée correctement. Si la ligne motor(30, -30, 5) cause une erreur, c’est probablement que le logiciel AlphAI n’a pas été démarré.

S’il n’y a pas d’erreur, vous observez le robot (ou le robot simulé dans le logiciel) tourner sur lui-même pendant 5 secondes.

La commande motor(left, right, duration) envoie les valeurs left et right aux moteurs gauche et droit du robot pendant la durée duration, après quoi il s’arrête. Les valeurs left et right doivent être comprises entre -50 et +50. Si la durée n’est pas précisée, alors le robot continue d’avancer jusqu’au prochain appel motor(0,0).

⚠️ Il est possible et parfois utile d’effectuer la connexion dans votre script python plutôt qu’en cliquant « connexion » dans le logiciel, en utilisant les fonctions connect_bluetooth(n) (en remplaçant n par le numéro de votre robot) ou connect_wifi(), ainsi que disconnect() pour se déconnecter.
Le code dans ce cas-là se présente ainsi :

from alphai import *

connect_bluetooth(n)
motor(30, -30, 5)

disconnect()

Vous trouverez à la droite de cette page, dans les annexes à télécharger, la documentation de la bibliothèque alpha-api qui contient l’ensemble des fonctions incluses dans la librairie alphai. Consultez-la dès maintenant pour en prendre connaissance.

‍

Premier script

Vous allez à présent créer un script Python dans votre environnement de programmation favori.

Créez un nouveau fichier Python et recopiez le code suivant :

from alphai import *

if _ _name_ _ == '_ _main_ _':
    connect_bluetooth(n)
    motor(30,30,1)
    disconnect()

Puis exécutez-le : le robot avance pendant une seconde puis s’arrête.

La commande motor(left, right, duration)envoie les valeurs left et right aux moteurs gauche et droit. Ces valeurs doivent être comprises entre -40 et +40. Naturellement, on arrête le robot avec motor(0, 0).

Vous trouverez à la droite de cette page, dans les annexes à télécharger, la documentation de la bibliothèque alpha-api qui contient l’ensemble des fonctions incluses dans la librairie alphai. Consultez-la dès maintenant pour en prendre connaissance.

Programmation d’une séquence

Pour faciliter la suite de votre codage, définissez les cinq fonctions suivantes. Faites des fonctions très simples : chacune doit seulement réaliser un appel à la fonction motor.

forward()

Fait avancer le robot tout droit.

backward()

Fait reculer le robot.

stop()

Arrête le robot.

left()

Fait pivoter à gauche le robot.

right()

Fait pivoter à droite le robot.

Enfin, créez une fonction walk_around() qui fait faire une séquence d’actions au robot en utilisant ces cinq fonctions. Testez-la en l’appelant dans le bloc main.

Programmation du téléguidage

Lecture des touches pressées

À l’aide de la fonction de l’API wait_for_key (voir les explications en dernière page) et d’une boucle while dans la fonction main, imprimez dans la console avec la fonction print les touches pressées sur le clavier. Pour éviter d’écrire une boucle infinie, prévoyez une touche spéciale qui permet de quitter la boucle, par exemple la touche « échap » (« esc » en anglais) :

keys = []

while "esc" not in keys:

    # n’oubliez pas l’indentation

Programmation du téléguidage

Toujours à l’aide de la fonction wait_for_key et d’une boucle while, créez une fonction remote_control()qui réagit aux touches directionnelles de telle sorte que le robot se déplace selon les instructions données au clavier. Pour récupérer la dernière touche enfoncée, sélectionnez le dernier élément dans la liste grâce à l’indice -1. Attention : la liste peut être parfois vide !

Pensez à faire stopper le robot lorsqu’aucune touche n’est pressée. Testez votre code en téléguidant le robot !

Pour aller plus loin

Nous allons pouvoir organiser des courses entre vos robots téléguidés, mais vous aurez aussi intérêt à améliorer votre programme en ajoutant de nouvelles commandes comme proposé ci-dessous… Ces améliorations ne sont que des propositions, n’hésitez pas à créer vos propres améliorations !

Différents virages

Créer deux nouvelles fonctions que vous pourrez utiliser lorsque la fonction wait_for_key renvoie une liste de plusieurs touches :

forward_left()

Fait avancer le robot vers la gauche lorsqu’on appuie simultanément sur les flèches du haut et de gauche. Ainsi on pourra faire faire au robot à la fois des virages serrés avec left() (flèche de gauche seule) et des virages larges avec forward_left() (flèches du haut et de gauche).

forward_right()

De même fait avancer le robot vers la droite lorsqu’on appuie simultanément sur les flèches du haut et de droite.

Freinage et boost

Ajouter des variables d’entrée à toutes vos fonctions pour pouvoir moduler la vitesse du robot, ou la force des virages, en fonction d’autres touchez qui seront pressées.

Par exemple ajoutez une variable d’entrée speed à toutes vos fonctions (par exemple forward(speed)), et appelez les fonctions avec une vitesse plus faible lorsqu’on appuie en même temps sur la barre d’espace (freinage), et plus forte lorsqu’on appuie en même temps sur la touche « x » (« boost »).

Pilotez votre robot et ajustez les paramètres de vitesse pour réussir à rendre le robot le plus maniable et le plus rapide possible. N’oubliez pas de vous exercer également à doubler des concurrents !

Programmation d’une séquence

Sur la touche de votre choix, faire réaliser au robot une petite chorégraphie, par exemple pour célébrer la victoire !

‍

Review and feedback

En programmation, la liste des fonctions accessibles d’un programme s’appelle API, pour Application Programming Interface, Interface de Programmation d’Application. Elle est utilisée par les programmeurs pour savoir comment interagir avec le programme. Vous trouverez l’API du module python alphai en suivant ce lien : https://drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view

Programmation caméra

Programmation Python : prise en main de l'ultrason et de la caméra pour programmer des déplacements autonomes du robot puis organiser une course de robots.

Contenu vidéo

Introduction

Le but de ce TP est de programmer AlphAI pour qu’il se déplace de manière autonome et non plus en mode « télécommandé » par l’élève comme dans le TP « AlphAI télécommandé ». Pour cela il faudra utiliser ses capteurs pour qu’il puisse réagir à son environnement, notamment pour détecter des obstacles. 

Nous allons voir un exemple rapide avec l’ultrason, puis passerons à la caméra pour organiser des courses de robots autonomes dans un circuit.

Navigation avec l’ultrason

Découverte du capteur ultrason

La fonction get_distance() (détails dans l’API en dernière page) renvoie la distance mesurée par l’ultrason du robot (en centimètres). Attention à bien activer le capteur avec la fonction set_distance(True) ou elle ne renverra pas une distance mais la valeur None.

Testez cette fonction avec le vrai robot avec le code suivant :

set_distance(True)  # active le capteur à ultrasons
while True:
    d = get_distance()  # récupère la valeur des ultrasons du robot
    print("distance:", d)

En déplaçant le robot à la main, vérifiez que la distance mesurée diminue lorsque le robot est face à un obstacle. Vous pourrez aussi remarquer que malheureusement si le robot est devant un mur, non pas pile en face de lui, mais en diagonale, ce mur n’est pas détecté (la distance mesurée est beaucoup plus grande car les ultrasons se reflètent sur le mur en diagonale sans revenir directement vers le robot).

Déplacement autonome avec l’ultrason

A l’aide de la fonction get_distance(), définissez puis testez une fonction ultrasound_race() qui fait avancer le robot tant qu’il ne perçoit pas d’obstacle avec son ultrason, et pivote à droite lorsqu’il détecte un obstacle. 

Ne cherchez pas à avoir un comportement parfait (ce serait difficile), dès que vous avez un comportement où le robot sait tourner s’il est face à un mur et aller tout droit s’il n’y a pas de mur, passez à la suite.

‍

Navigation avec la caméra

La caméra apporte une information beaucoup plus riche que le capteur de distance ultrason, et permettra de prendre des décisions plus sophistiquées.

Découverte de l’image caméra

Commençons par afficher l’image de la caméra du robot dans le logiciel. Ouvrez l’onglet de paramètres « Capteurs » à gauche, et choisissez le mode de caméra « image 64x48 »

: l’image de ce que voit le robot apparaît. 

Une image est une grille de pixels ; dans une image couleur comme c’est le cas ici, chaque pixel contient 3 valeurs : les intensités de rouge, vert et bleu dans ce pixel. Pour voir cela de manière plus précise, choisissez à présent le mode de caméra avec la résolution faible « image 8x6 »

, et dans l’onglet « Visualisation » cochez « Caméra : résolution dégradée »

: une image très grossière apparaît, et les valeurs rouge/vert/bleu de chaque pixels sont affichées (valeurs entre 0 et 255). 

Pour régler la résolution d’image dans le code Python plutôt que dans le logiciel, il faut commencer par initialiser la caméra, par exemple set_camera("8x6"). Ensuite on récupère l’image avec get_camera(). Cette fonction renvoie un tableau de dimension 3 sous la forme d’un objet « List ». La seule chose à savoir pour ce TP à propos de cet objet est comment accéder aux valeurs des pixels : Si on appelle image cet objet renvoyé, on accède à la valeur du pixel de la ligne i, colonne j et dans le canal k (k=0 pour rouge, 1 pour vert, 2 pour bleu) avec image[i][j][k].

Copiez et exécutez le code suivant, et vérifiez que les 3 valeurs affichées correspondent bien aux 3 valeurs rouge/vert/bleu dans le logiciel du pixel à la 5^ème ligne en partant du haut (indice 4 quand on commence à compter à zéro) et de la 4^ème colonne en partant de la gauche (indice 3).

from alphai import *

from time import sleep

set_camera("8x6")  # active la caméra à la bonne resolution

sleep(1)  # attend 1s que le logiciel active la caméra

while True:
    image = get_camera()  # récupère l’image de la caméra

    line = image[4]

    pixel = line[3]
    print('rouge', pixel[0], 'vert', pixel[1], 'bleu', pixel[2])

Premier déplacement autonome avec la caméra

Nous voulons que le robot effectue de manière autonome des tours de circuit. Si vous utilisez une arène fournie avec les robots AlphAI, le sol est blanc, l’enceinte extérieure est rouge, et l’ilôt central est noir. Nous supposerons que c’est le cas, et que vous voulez faire circuler le robot en tournant dans le sens des aiguilles d’une montre. 

Commencez par écrire une fonction camera_race() pour prendre les décisions répétitivement, de la manière suivante (qui se base uniquement sur la couleur d’un seul pixel dans la partie basse de l’image) :

Si image[4][3][0] < 100 (canal rouge sombre 🡪 le pixel est noir), pivoter à gauche à vitesse 25 pendant 0.5 seconde.

‍

Sinon, si image[4][3][1] < 100 (canal rouge lumineux et canal vert sombre 🡪 le pixel est rouge), pivoter à droite à vitesse 25 pendant 0.5 seconde.

Sinon (canaux rouge et vert lumineux 🡪 le pixel est blanc), aller tout droit à vitesse 40 pendant 0.5 seconde.

‍

Testez ce programme sur la piste.

‍

Pour rappel, la structure si, sinon si, sinon est de la forme suivante en Python :

if condition_1:

action_1()

elif condition_2:

action_2()

else:

action_3()

Compter les pixels de différentes couleurs

Vous avez probablement constaté que prendre des décisions à partir d’un seul pixel n’étaient pas toujours le mieux. Par exemple il peut arriver que le pixel de la 5^ème ligne / 4^ème colonne soit blanc donc le robot décide d’avancer, alors qu’il y a un mur sur le côté et qu’il devrait plutôt tourner.

Pour améliorer le programme, nous allons considérer tous les pixels de l’image de la caméra. Tout d’abord nous allons compter combien de pixels sont noirs, rouges et blancs. Ensuite la décision sera prise ainsi : si la majorité des pixels sont rouge, tourner à droite ; si la majorité des pixels sont sombres, tourner à gauche ; et sinon aller tout droit.

Pour compter le nombre de pixels d’une certaine couleur, réalisez une suite de boucles for pour chaque composante de l’image : les lignes et les colonnes puis comptez pour chaque pixel quelle est sa couleur à l’aide des valeurs de rouge, de vert et de bleu qui la compose. Vous pouvez vous inspirer des seuils précédemment trouvés afin de déterminer la couleur du pixel. Vous pouvez commencer à partir du code suivant ou trouver votre propre façon de faire, il en existe plusieurs ! 

def count_pixel_colors(image: list):

# créer dict ici

nombre_pxl_noir = 0

nombre_pxl_rouge = 0

nombre_pxl_blanc = 0

for i in range(len(image)):

ligne = image[i] 

for j in range(len(ligne)):

pixel = ligne[j]

canal_rouge = pixel[0]

canal_vert = pixel[1]

canal_bleu = pixel[2]

if ...

nombre_pxl_noir +=1

...

else:

...

return {"noir": nombre_pxl_noir, "rouge": nombre_pxl_rouge, "blanc": nombre_pxl_blanc}

Astuce Syntaxe Python pour les boucles for, au lieu d’utiliser des indices i et j pour accéder aux éléments d’un tableau, vous pouvez changer de syntaxe et écrire tout simplement :

for ligne in image:
for pixel in ligne:
rouge = pixel[0]
vert = pixel[1]
bleu = pixel[2]
…

Course de robots autonomes et poursuite des améliorations

A présent, vous pouvez commencer à organiser des courses entre vos robots. 

Celles-ci seront encore plus pimentées si vous continuez de chercher à améliorer votre programme en modifiant par exemple : les vitesses de déplacement, les seuils des couleurs, des actions supplémentaires (en plus du tournant en pivotant sur place, un virage en avançant vers l’avant), etc.

‍

Review and feedback

‍

En programmation, la liste des fonctions accessibles d’un programme s’appelle API, pour Application Programming Interface, Interface de Programmation d’Application. Elle est utilisée par les programmeurs pour savoir comment interagir avec le programme. Vous trouverez l’API du module python alphai en suivant ce lien : https://drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view

‍

TP à télécharger (prof et élève)

Documentation de la bibliothèque alphai-api

Related courses

‍

Algorithme KNN avancé

Activité  ludique pour classe avec plusieurs robots : les élèves entraînent les robots à rouler dans un circuit puis une course est organisée. Les élèves apprennent par la manipulation le principe de l'apprentissage supervisé et l'importance de la qualité des données d'entraînement.

Contenu vidéo

Introduction

Machine learning et apprentissage supervisé

Le Machine Learning est une branche de l’intelligence artificielle qui a pour but de donner la possibilité aux ordinateurs d’apprendre. Un ordinateur n’est pas intelligent, il ne fait qu’exécuter des tâches. On lui décrit sous forme de programmes quoi faire et comment le faire. C’est ce qu’on appelle la programmation.

Le Machine Learning traite des sujets complexes où la programmation traditionnelle trouve ses limites. Construire un programme qui conduit une voiture serait très complexe voire impossible. Cela étant dû aux très nombreux cas possibles à traiter… Le Machine Learning traite cette problématique différemment. Au lieu de décrire quoi faire, le programme apprendra par lui-même comment conduire en “observant” des expérimentations.

Machine Learning : Donner la possibilité à un programme d’apprendre des tâches qui n’ont pas été programmées.

En fonction des données d’expérimentations que prendra l’algorithme d’apprentissage en entrée, il déduira par lui-même une hypothèse de fonctionnement. Il utilisera cette dernière pour de nouveaux cas, et affinera son expérience au fil du temps.

Il existe trois types d‘apprentissages en Machine Learning :

• Apprentissage Supervisé
• Apprentissage Non supervisé
• Apprentissage par Renforcement

L’apprentissage supervisé est le type le plus courant. Il s’agit de fournir aux algorithmes d’apprentissages un jeu de données d’apprentissage (Training Set) sous forme de couples (X, Y) avec X les variables prédictives (ou données d’entrée), et Y le résultat de l’observation (ou décision). En se basant sur le Training Set, l’algorithme va trouver une fonction mathématique qui permet de transformer (au mieux) X vers Y. En d’autres termes l’algorithme va trouver une fonction F tel que Y≈F(X) .

Ainsi, dans une situation X, il saura quelle décision Y doit prendre.

Situation d'étude et training set du robot AlphAI

Il convient désormais de préciser les situations X et les décisions Y attendues. 

Le cas d’étude proposé est le déplacement du robot dans une arène rouge. L’objectif est que le robot se déplace tout seul sans jamais toucher les murs.

Pour cela le robot pourra prendre les décisions suivantes :

• Tourner à gauche 
• Aller tout droit 
• Tourner à droite 

Afin de prendre la décision il faut nécessairement un retour d’information afin de disposer de données (data ou training set).

Cela est donné par les capteurs. Le choix effectué ici est d’utiliser la caméra. De la zone d’image de la caméra il est extrait deux zones qui seront appelées super pixels (voir ci-contre). La quantité de rouge de chaque super-pixel augmente lorsque le robot s’approche des murs en raison du contraste entre la piste blanche et les murs rouges.

‍

‍

Activité 1. Indiquer dans le tableau ci-dessous le résultat attendu comme décision en fonction de ce qui est repéré dans les superpixels.

‍

Les cas simplifiés ci-dessus, ne se produisent que très rarement. Pour pouvoir prendre la décision dans tous les cas possibles, il faut obtenir la valeur numérique du niveau de rouge. 

L’image issue de la caméra est de taille 48*64 pixels. La position et la géométrie des super-pixels est définie par la figure suivante :

‍

‍

Activité 2. Ouvrir le fichier get_values.py. Indiquer le chemin d’accès de l’image forward_0.jpg et exécuter le code ci-dessous permettant d’afficher l’image dans python.

from PIL import Image

import numpy as np

import matplotlib.pyplot as plt

def read_image(name):

    return np.array(Image.open(name, "r"))

img1=read_image("forward_0.jpg") #indiquer le chemin d'accès de l'image

plt.imshow(img1)

plt.show()

Vous devez obtenir une image de la forme ci-dessous d’une taille de 48 pixels par 64 pixels, codée avec les trois couleurs RVB (Rouge Vert Bleu).

« img1 » est un tableau de pixels de taille 48*64*3

Dans le tableau de pixel on retrouve les 3 niveaux de couleurs Rouge Vert Bleu codés entre 0 et 255.

A partir de cette image, il va falloir extraire les deux super-pixels définis précédemment et déterminer une méthode permettant d’obtenir le niveau de rouge pour chacun.

‍

‍

Nous allons comparer différentes techniques pour obtenir le meilleur contraste entre le rouge et le blanc de chaque super-pixel :

• le niveau de gris moyen de chaque super-pixel
• le niveau de rouge moyen de chaque super-pixel
• le niveau de vert moyen de chaque super-pixel

‍

Dans un premier temps, l’image est transformée en niveau de gris à l’aide de la fonction rgb2gray de la façon suivante :

def rgb2gray(rgb):

    return np.dot(rgb[...,:3], [0.299, 0.587, 0.144])

img2=rgb2gray(img1)

plt.imshow(img2, cmap="gray")

plt.show()

« img2 » correspond à l’image en niveau de gris. Ainsi il n’y a qu’une seule valeur numérique entre 0 et 255 pour chaque pixel. 0 correspond à un pixel blanc et 255 un pixel noir. Les super pixels étant dans la zone « basse » de l’image

‍

‍

Activité 3. Ecrire une fonction moyenne(img,x,y,height,width)   qui va prendre en argument un tableau de pixels « img » à un niveau de couleur, les coordonnées « x » et « y » du pixel en haut à gauche d’un super-pixel, la hauteur « height » et la largeur « width » d’un super-pixel et qui renvoie la moyenne du niveau de couleur du super-pixel. 

‍

Il est ainsi possible de récupérer deux valeurs avec les deux super-pixels définis précédemment à l’aide du code :

def get_two_values(img, x1=10, y1=28, x2=42, y2=28, height=16, width=13):

    value1 = moyenne(img, x1, y1, height, width)

    value2 = moyenne(img, x2, y2, height, width)

    return np.array((value1, value2))

Le niveau de couleur du super-pixel gauche est noté value1, le niveau de couleur du super-pixel droit est noté value2. Il est ainsi possible de définir un point de coordonnées (value1, value2)

‍

‍

Activité 4. Executer le code pour récupérer les valeurs value1 et value2 de l’image en niveau de gris obtenue précédemment.

Le choix effectué dans le logiciel AlphAI est d’utiliser la fonction de python mean qui va calculer la valeur moyenne du tableau.

‍

‍

‍

Activité 5. Appliquer la méthode du logiciel AlphAI et celle avec le niveau de gris et compléter avec les valeurs value1 et value2 dans les deux cas.

Fonction mean

Niveau Gris

Forward_0

Forwad_1

Left_0

Left_1

Right_0

Right_1

Right_2

Test_0

Test_1

‍

‍

Activité 6. Placer les points sur le graphique et identifier les zones correspondant aux différentes décisions (tourner à gauche, aller tout droit, tourner à droite). Conclure sur la méthode qui vous semble la plus appropriée pour distinguer les différentes décisions.

Intensité super-pixel droit

Intensité  super-pixel gauche

‍

À ce stade, il serait possible de piloter le robot à partir d’actions conditionnelles portant sur ces valeurs de super-pixels. L’approche va être différente dans la suite. Nous allons utiliser une méthode portant le nom d’algorithme des K plus proches voisins.

‍

L’algorithme des k plus proches voisins, KNN

Nous allons étudier de près un algorithme très connu parmi les algorithmes de machine learning : l’algorithme des K plus proches voisins, ou KNN en anglais pour « K Nearest Neighbours ». Cet algorithme a l’avantage d’être très simple, et donc de fournir une bonne base pour comprendre l’apprentissage supervisé.

L'idée est d'utiliser un grand nombre de données afin "d'apprendre à la machine" à résoudre un certain type de problèmes. L’algorithme est particulièrement intuitif quand les données se présentent comme des points dans un espace de dimension 2, qui pourront donc être affichés à l’écran. Nous allons donc choisir une configuration avec seulement 2 entrées capteurs, à savoir 2 « super-pixels » de la caméra afin de permettre au robot de repérer les murs et de circuler dans l’arène sans blocage. Dans un premier temps ce sera à nous d’indiquer au robot l’action associée pour chaque nouvelle donnée (2 « super-pixels »), mais ensuite il sera capable de circuler par lui-même en choisissant l’action majoritaire prise par les K plus proches voisins parmi les données entrées pendant la phase d’entraînement.

Cet algorithme d’apprentissage supervisé permet de classifier des données en fonction de leur proximité avec celles existantes constituant les données d’entraînement. Les nouvelles données considèrent k voisins, les k plus proches, pour choisir quelle classification appliquer. Avec des données discrètes, comme des points dans un plan ou dans l’espace, les plus proches voisins sont sélectionnés en utilisant la distance euclidienne, mais d’autres méthodes peuvent être utilisées dans d’autres situations, comme la distance Manhattan si les données se placent sur un quadrillage ou un échiquier. L’intérêt de cet algorithme réside dans le choix de k : trop petit et l’algorithme devient trop sensible aux erreurs ou aux données manquantes, trop grand et il considère des données qui ne devraient pas être considérées.

On peut schématiser le fonctionnement de k-NN en l’écrivant en pseudo-code suivant :

Début Algorithme

Données en entrée :

• un jeu de données D, correspondant au training set élaboré
• une fonction de calcul de distance entre les deux points considérés de coordonnées [x1,y1] et [x2,y2]. d=x2-x12+y2-y12
• Un nombre entier k, représentant le nombre de voisins à prendre en compte

Pour une nouvelle observation X dont on veut prédire sa décision Y Faire :

1. Calculer toutes les distances de cette observation X avec les autres observations du jeu de données D
2. Retenir les K observations du jeu de données D les plus proches de X en utilisation la fonction de calcul de distance d
3. Prendre les valeurs de Y des k observations retenues. Effectuer une régression et calculer la moyenne (ou la médiane) de Y retenues 
4. Retourner la valeur calculée dans l’étape 3 comme étant la valeur qui a été prédite par K-NN pour l’observation X.

Fin Algorithme

Il faut donc pouvoir calculer la distance entre deux points. Dans un graphique en deux dimensions comme c’est le cas dans notre exemple, cela correspond simplement à la norme du vecteur entre les deux points.

Activité 1. Ecrire la fonction distance(point1, point2)   qui prend en argument deux points (point1=[x1,y1], point2=[x2,y2])  et qui renvoie la distance entre ces deux points.

Activité 2. Compléter le tableau ci-après en déterminant la distance entre les super-pixels des images précédentes (forward_0.jpg, forward_1.jpg,…) et des deux images tests (test_0.jpg et test_1.jpg).

‍

Activité 3. Appliquer les étapes 3 et 4 de l’algorithme K-NN en en prenant K=1,2,3 et 4 et en déduire la décision qui doit être prise (aller tout droit, tourner à gauche, tourner à droite).

‍

‍

Entrainement du robot

Phase de préparation de l’environnement de travail

• Dans le menu Paramètres - > Charger des configurations d'exemples, sélectionner la configuration exemple « apprentissage supervisé - KNN Caméra». 

Attention : Pour ce scénario, afin d’obtenir le meilleur contraste possible, mettez une surface blanche au sol, et Assurez-vous d’avoir un éclairage uniforme sur la surface de l’arène.

‍

Phase d’entraînement

Activité 1. Suivre le protocole afin de réaliser la phase d'entraînement

‍

Vous êtes maintenant connecté au robot, et votre écran doit ressembler à l’image ci-dessous. Le niveau de sa batterie doit s’afficher en bas à droite (vérifiez que le robot est bien chargé).

• Tant que le robot a de la place pour avancer, appuyez sur aller tout droit. 

• Si le robot s’approche d’un mur, appuyez sur virage sur place à gauche ou à droite. 

À chaque instruction envoyée au robot, un nouveau point est ajouté au graphique. L’abscisse de ce point correspond à la valeur du super-pixel de gauche et son ordonnée correspond à la valeur du super-pixel de droite. La couleur de chaque point correspond à l’action choisie : jaune pour aller tout droit, vert pour tourner à droite et rouge pour tourner à gauche. Ces points sont les données d’entraînement. Cette phase d’entraînement est primordiale pour que l’IA puisse apprendre correctement. Si les données d’entraînement contiennent trop d’erreurs ou d’approximations, le comportement de l’IA risque de ne pas être satisfaisant. 

Notez bien :

Les pixels deviennent plus sombres lorsque le robot s’approche des murs. Normalement si le pixel de gauche est le plus sombre, il faut tourner à droite, et si le pixel de droite est le plus sombre, il faut tourner à gauche. Après avoir ajouté quelques points sur le graphique, vous pouvez activer la couleur d’arrière-plan dans l’onglet des paramètres de visualisation. Cette option colore chaque pixel du graphique de la couleur du point de donnée le plus proche.

Lorsque vous aurez trois régions bien claires sur le graphique, arrêtez la phase d’entraînement et réactivez l’autonomie pour passer à la phase de test.  Ne pas hésiter à bouger le robot à la main, lorsqu’une zone du graphique contient trop peu de points.

‍

‍

Tests

Si le robot est bien entraîné, il saura éviter les bords par lui-même. Si au contraire il est mal entraîné ou la luminosité dans l’arène n’est pas homogène, cela va produire du bruit dans les régions créées et le robot fera plus d’actions inappropriées.

Notez bien :

Afin d’obtenir le meilleur comportement du robot, il faut tester plusieurs valeurs de k. Pour changer cette valeur, allez dans l’onglet « IA » et changer la valeur du paramètre « nombre de voisins ».

Une bonne valeur de k réduit l’effet du bruit et permet au robot de mieux gérer les régions inexplorées.

Une fois que le robot est bien entraîné et que les tests se déroulent bien, vous pouvez passer aux activités.

‍

Activité 1. Comparez le comportement du robot avec k=1, k=3, k=10 et k=30. Ensuite, d’après ce que vous constatez, essayer de déterminer la valeur de k qui minimise l’effet des erreurs et donne le meilleur comportement du robot, c’est-à-dire la plus grande distance parcourue sans heurter un mur. La bonne valeur va dépendre du nombre de points de données, et du nombre d’erreurs dans ces données.

‍

Activité 2. Maintenant que vous avez bien compris l’algorithme, essayez d’entrainer le robot avec le minimum de données possibles qui lui permettent de tourner sans taper contre les murs. 

‍

Commencez par faire une version théorique en dessinant les zones que vous voudriez obtenir sur votre graphique. Quels points sont à placer pour la réaliser ? Testez ces points avec le robot après les avoir rentrés dans le logiciel. Votre modèle théorique a-t-il été applicable à la réalité, ou avez-vous dû y faire des modifications ? Quelles sont les limitations de cette méthode pour un robot tel que celui-là ?

Astuce : Vous pouvez déplacer le robot à la main pour choisir les points que vous voulez lui apprendre.

Remarque : Nous avons réussi à apprendre au robot à circuler dans l’arène sans taper les murs avec 3 points seulement.

Pour aller plus loin :

‍

Activité 3. S’il vous reste du temps et que vous voulez expérimenter, changez d’algorithme et regardez quelles différences le robot a dans son comportement par rapport à KNN. Quel autre algorithme proposé à un apprentissage plus rapide ? Et quel autre algorithme permettrait, selon vous, l’apprentissage de tâches plus complexes, comme taper dans un ballon vert ou reconnaître des ordres communiqués avec des signes de la main ?

‍

Programmer l’algorithme des K plus proches voisins

1. Stoppez le robot et réactivez le bouton « Autonome ».

2. Dans l’onglet IA, sélectionnez  Algorithme : code élève , cela ouvrira une nouvelle fenêtre vous demandant de nommer le fichier. 

3. Après lui avoir donné un nom, le fichier apparaît dans l’explorateur Windows : ouvrez-le dans votre éditeur de code préféré (Spyder, par exemple).

Ce code présente 3 fonctions déjà existantes : init, learn et take_decision. Ces fonctions seront appelées par le logiciel principal. Seule la fonction take_decision est importante pour ce TP.

4. Remarquez que quand vous vous déconnectez, un mini-robot simulé apparaît en bas à droite. Si vous le voulez, vous pouvez faire les questions ci-dessous avec ce mini-robot et revenir au vrai robot à la fin du TP ; mais vous pouvez aussi faire tout le TP en restant connecté au vrai robot : comme vous préférez !

‍

PROGRAMMER LE ROBOT DIRECTEMENT

Avant de programmer une intelligence artificielle, commençons par comprendre le principe de la fonction take_decision. Vous allez pouvoir modifier cette fonction pour changer le comportement du robot : après chaque modification, sauvegardez votre code et cliquez sur le bouton « Réinitialiser l’IA ». Cette étape est à répéter pour chaque modification du code : sauver puis recharger le code.

La fonction a le prototype suivant :

take_decisionsensors:listint

L’entrée sensors est l’état des capteurs du robot, c’est-à-dire dans notre cas une liste de deux valeurs sensors[0] et sensors[1] qui sont l’intensité de ce que voit le robot à sa gauche et à sa droite. Sa sortie est le numéro de l’action choisie.

1. Ajoutez l’instruction print(sensors) à l’intérieur de la fonction. Sauvegardez, cliquez « Réinitialiser l’IA » dans le logiciel, et démarrez le robot. La valeur de sensors s’affiche maintenant dans la console (cliquer dans la barre des tâches sur l’icône pour afficher la console). Quelle est à peu près la valeur de sensors quand le robot est face à un mur ? quand il n’est pas face à un mur ? quand il y a un mur à sa gauche ou à sa droite ?

‍

2. Pour l’instant la fonction renvoie 0. Quelle valeur faut-il renvoyer pour que le robot aille tout droit ? (Faites l’essai)

‍

3. Utilisez la variable x pour programmer un comportement cohérent du robot : « s’il n’y a pas de mur, je vais tout droit ; s’il y a un mur, je me tourne. »

‍

PROGRAMMATION DE L’ALGORITHME

Calcul de distance

Si vous ne l’avez pas déjà fait lors de l’activité précédente, programmez une nouvelle fonction distance qui prend comme arguments deux points a et b qui sont deux tableaux de deux éléments chacun contenant leurs coordonnées et qui renvoie la distance euclidienne de ces deux points. Le prototype de la fonction est le suivant :

distancea:list, b:listfloat

Avec a=x1, y1 et b=x2, y2

Pour rappel, la distance euclidienne entre ces deux points est : d=x2-x12+y2-y12.

La racine carrée peut être utilisée en Python en important la bibliothèque math (ou numpy) en haut du fichier :

import math

et s’écrit ainsi :

y = math.sqrt(x)

L’opérateur carré peut être fait de la façon suivante :

y = x**2

4. Programmez la nouvelle fonction distance. Puis pour la tester, écrivez en bas du fichier :

# compute distance

a = [0, 0]
b = [1, 2]
print("distance", distance(a, b))

Sauvez, chargez le code avec « Réinitialiser l’IA » et notez ci-dessous le résultat qui s’affiche dans la console :

‍

Calcul de toutes les distances

Maintenant que vous avez une méthode pour calculer une distance, écrivez une nouvelle fonction all_distances qui calcule toutes les distances d’un point par rapport à la variable train_sensors qui sont les données d’entrée d’entrainement. Cette fonction prendra comme argument un nouveau point x qui est une liste de deux éléments comme précédemment, et renverra un tableau contenant toutes ces distances. Son prototype est :

all_distances(a:list[float], train_sensors:list[list[float]])→list[float]

Avec a=x0, y0 et train_sensors=x1, y1, x2, y2, …, xn, yn Le tableau train_sensors étant de longueur n.

‍

5. Programmez all_distances, puis testez avec le code suivant en bas du fichier :

# compute all distances

a = [0.4, 0.6]

train_sensors = [[0, 0], [0, 1], [1, 0]]

distance_list = all_distances(a, train_sensors)

print('distances to data', distance_list)

Rechargez le code et recopiez votre résultat :

‍

Trouver le plus petit element d’un tableau

Créez une fonction s’appelant find_minimum prenant comme unique argument un tableau et renvoyant l’indice du premier plus petit élément. Son prototype est :

find_minimum(dlist:listfloat)→int

6. Programmez et testez find_minimum avec le code suivant :

# minimum in a list

idx_min = find_minimum(distance_list)

print('index of minimum', idx_min)

Notez le résultat :

‍

Le plus proche voisin

Maintenant que nous avons toutes les fonctions nécessaires, nous allons pouvoir créer la fonction nearest_neighbor_decision qui prend comme argument les données d’entrainement et l’entrée de la caméra actuelle, et qui renvoie la commande à envoyer au robot. Son prototype est :

nearest_neighbor_decision(train_sensors:list[listfloat],train_decisions:list[int],a:list[float])→int

Comme précédemment, a=x0, y0 et  train_sensors=x1, y1, x2, y2, …, xn, yn et train_decisions = d1,…,dn où chaque di est la décision prise pour le point xi, yi dans le tableau train_sensors. 

Pour réaliser la fonction, calculez les distances, trouvez la plus courte et renvoyez la commande associée en utilisant train_decisions.

‍

7. Programmez et testez nearest_neighbors_decision avec le code suivant :

# KNN

a = [0.4, 0.6]

train_sensors = [[0, 0], [0, 1], [1, 0]]

train_decisions = [1, 2, 0]

decision = nearest_neighbor_decision(train_sensors, train_decisions, a)

print('KNN', decision)

Recopiez le résultat :

‍

UTILISATION DE VOTRE ALGORITHME AVEC LE ROBOT 

Félicitations, vous avez programmé vous-mêmes l’algorithme des K plus proches voisins dans le cas K=1. Il ne vous reste plus qu’à l’utiliser dans le programme pour entraîner le robot.

Pour cela, recopiez les lignes ci-dessous pour programmer la fonction take_decision pour prendre les bonnes décisions, mais également learn pour se rappeler des données d’entraînement train_sensors et train_decisions qui seront créées au fur et à mesure dans le programme principal :

train_sensors = train_decisions = None

def learn(X_train, y_train):
    global train_sensors, train_decisions
    train_sensors, train_decisions = X_train, y_train
    loss = 0
    return loss

def take_decision(sensors):
    if train_sensors is None:
        return 0
    return nearest_neigbor_decision(train_sensors, train_decisions, sensors)

 Et à présent, vous pouvez entraîner votre robot !

1. Rechargez votre code

1. Désactivez l’autonomie du robot en cliquant sur l’icône

1. ,
2. Dirigez le robot en cliquant sur les flèches à droite de l’écran. Tournez quand le robot est proche des murs et allez tout droit sinon. 

Les tableaux train_sensors et train_decisions sont remplis automatiquement par le logiciel à chaque fois que vous cliquez une flèche.

4. Après un court apprentissage, réactivez l’autonomie

4. Le robot navigue seul dans l’arène. Évite-t-il les murs par lui-même ?

‍

‍

Pour aller plus loin

K plus proches voisins

L’algorithme que vous avez écrit utilise le plus proche voisin pour prendre sa décision. Modifiez votre code pour qu’il prenne en compte la majorité des décisions prises entre un nombre k>1, k∈N. La difficulté réside dans la modification de la fonction trouvant le minimum. Il faut maintenant qu’elle en trouve k et non juste 1.

InTroduction aux réseaux de neurones

Chargez les configurations d'exemple « Apprentissage supervisé, navigation avec caméra » et relancez un apprentissage. Quelles différences existe-il entre les deux algorithmes ? 

Review and feedback

‍

En programmation, la liste des fonctions accessibles d’un programme s’appelle API, pour Application Programming Interface, Interface de Programmation d’Application. Elle est utilisée par les programmeurs pour savoir comment interagir avec le programme. Vous trouverez l’API du module python alphai en suivant ce lien : https://drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view

Q-learning ou programmation avec Pytorch

Programmation de la fonction de récompense que reçoit le robot pour réaliser un apprentissage original : suivre une ligne avec la caméra, … ou autre chose !

Contenu vidéo

Introduction

Découverte du logiciel AlphAI

Le logiciel AlphAI permet de (re)découvrir de manière visuelle le Machine Learning en général, et les algorithmes d’apprentissage supervisé et par renforcement en particulier : réseaux de neurones, KNN, Q-learning, DQN, etc.

• Lancez le logiciel en cliquant sur l’icône « AlphAI » sur le Bureau ou depuis le menu démarrer.

Si le logiciel demande quel robot choisir, choisissez « AlphAI ». Ensuite, nous allons commencer par utiliser le robot simulé. Cliquez sur le bouton « Simulation ».

PRINCIPE DE L’APPRENTISSAGE SUPERVISÉ DANS LE LOGICIEL

Voici les éléments principaux du logiciel :

• Appuyez sur

• , vous voyez le réseau prendre une décision, liée à l’initialisation aléatoire des connexions dans le réseau
• Appuyez sur

• , les connexions ont été réinitialisées et les décisions ne sont plus les mêmes
• Mettez vous en mode avancé puis dans l’onglet Visualisation activez l’affichage de la valeur des connexions pour voir le détail des calculs effectués par le réseau de neurones

A présent nous allons entraîner le réseau de neurones en construisant et lui donnant au fur et à mesure un jeu de données de 2 données :

• Quand le robot n’est pas bloqué (roues vertes)

• , appuyez sur la flèche « tout droit »

• (vous pouvez aussi utiliser la flèche du haut du clavier). 
• Et quand il est bloqué (roues rouges)

• , appuyez sur une flèche « arrière »

• (ou flèche arrière du clavier).
• Désormais vous avez créer deux données

• qui ont permis à l’algorithme d’apprentissage de modifier les connexions à l’intérieur du réseau de neurones, de telle sorte que désormais quand on le passe en mode autonome, il choisit d’aller tout droit quand le robot n’est pas bloqué, et de se retourner sinon.

Continuez d’explorer le logiciel :

• Dans l’onglet capteur changez les entrées du réseau de neurones
• Dans l’onglet action changez les actions possibles
• (Ignorez pour l’instant l’onglet Récompense, qui ne s’applique que pour l’Apprentissage par Renforcement)
• Dans l’onglet IA, changez les couches de neurones intermédiaires. Vérifiez que l’IA n’apprend pas quand on met la vitesse d’apprentissage à zéro, et que l’apprentissage diverge lorsqu’on la met à une valeur trop grande.
• Dans l’onglet Visualisation testez les paramètres d’affichage de la rubrique « Réseau de neurones ». Remarquez comment

• va permettre de visualiser les connexions qui augmentent ou diminuent pendant l’apprentissage.

‍

APPRENTISSAGE D’UN CIRCUIT

Activez un mode de caméra, choisissez les actions que vous voulez, essayez de régler les paramètres de l’IA comme il faut, et faites apprendre au robot simulé à faire des tours de piste !

Notez encore que vous pouvez modifier la vitesse du robot en bas

.

CONNEXION AU VRAI ROBOT

Une fois que vous pensez avoir correctement réglé tous les paramètres vous allez pouvoir connecter le vrai robot !

• Déconnectez-vous du robot simulé (

• en bas à droite)

• Montez une arène de course.
• Allumez le robot (l’interrupteur se trouve en dessous). Il effectue un petit mouvement puis clignote en blanc une fois qu’il est prêt à recevoir une connexion. 
• Notez le numéro du robot inscrit sur sa plaque du dessous.
• Choisissez si vous voulez vous connecter en Wi-Fi ou en Bluetooth (le Wi-Fi sera nécessaire la première fois pour mettre à jour les robots avec la version la plus récentes du logiciel ; mais le Bluetooth ensuite pourra être préférable pour une connexion plus stable).

Connexion Wi-Fi

• Connectez l’ordinateur au Wi-Fi du robot : cherchez le réseau Wi-Fi qui commence par ALPHAI et se termine par le numéro de votre robot ; le mot de passe est identique au nom du wifi
• Cliquez sur l’icône du robot qui apparaît dans le logiciel, avec un petit logo wifi.

Connexion Bluetooth

• Allez dans les paramètres Bluetooth de Windows et appairez votre robot (« ajouter un nouvel appareil »).
• Cliquez sur l’icône du robot qui apparaît dans le logiciel, avec un petit logo Bluetooth.

COURSE DE ROBOT

Vous pouvez à présent entraîner votre robot à faire des tours de circuit et organiser une course contre un ou deux collègues dans l’arène !

DETAIL DU RESEAU DE NEURONES : DETECTION D’INTRUS

Dans le menu Paramètres > Charger des configurations d'exemples, chargez la configuration de démonstration 

Vous voyez un tout petit réseau de neurones. Essayez de lui faire apprendre à faire sonner l’alarme du robot lorsqu’il est à 30cm d’un objet, mais à arrêter l’alarme si l’objet et à moins de 25cm, ou à plus de 35cm :

Vous allez constater que c’est impossible avec le réseau initial qui est trop simple. Vous allez devoir ajouter un biais aux neurones, et au moins une couche de 2 neurones intermédiaires.

Programmation du réseau de neurones

Travaillez au début avec le robot simulé, ce sera plus simple, vous pourrez revenir aux vrais robots à la fin. Éteignez le robot pour économiser ses batteries.

Dans l’onglet IA, choisissez algorithme : « code élève », puis répondez « Nouveau » à la question qui vous est posée et choisissez le nom du fichier où sauver votre code.

Vous allez éditer le code de 3 fonctions « init », « learn » et « take_decision » pour coder votre propre réseau de neurones.

Compréhension des 3 fonctions

1. Ajouter des print dans chacune des 3 fonctions et constatez que 

• init est appelée lorsqu’on appuie sur « Réinitialiser l’IA »
• learn est appelée le plus souvent possible (mais seulement si le bouton « Apprentissage » est activé et qu’il y a des données d’apprentissage dans la mémoire d’expérience)
• take_decision est appelée à chaque fois que le programme veut connaître une décision (il est appelé en fait 2 fois par étape : 1 fois pour l’affichage des valeurs à l’écran, 1 fois pour faire prendre la décision au robot

2. Modifiez la valeur renvoyée par la fonction take_decision : elle détermine l’action que choisit le robot en mode autonome

‍

Coder un premier réseau « en-dehors » du logiciel

Voici un code qui construit un réseau de neurones avec 1 entrée, 2 sorties (correspondant à 2 catégories), et une couche intermédiaire de 100 neurones.

Il l’entraîne sur un jeu de 3 données (x=-2 🡪 catégorie 1), (x=0 🡪 catégorie 0), (x=2 🡪 catégorie 1) et vérifie que l’erreur est faible au terme de l’apprentissage.

    import torch as th

    from torch import nn

    import numpy as np

    ninput = 1

    noutput = 2

    # Example data set

    data = [[-2], [0], [2]]

    classes = [1, 0, 1]

    data = th.Tensor(data)

    classes = th.LongTensor(classes)

    # Init neural network

    network = nn.Sequential(

            nn.Linear(ninput, 100),

            nn.LeakyReLU(),

            nn.Linear(100, noutput),

    )    

    print("first layer: weights = ", network[0].weight)

    print("first layer: bias = ", network[0].bias)

    # Test network output before learning

    sensors = th.Tensor([[0], [1], [2]])

    output = network(sensors)

    print(output)

    # Init loss function

    lossfn = nn.CrossEntropyLoss()

    pred = network(data)

    print("loss:", lossfn(pred, classes))

    # Init optimizer

    optimizer = th.optim.SGD(network.parameters(), lr=1e-1)

    # Learning

    nrepeat = 2000

    for i in range(nrepeat):

        optimizer.zero_grad()

        pred = network(data)

        loss = lossfn(pred, classes)

        print("loss:", lossfn(pred, classes))

        loss.backward()  # this computes the gradient, i.e. the derivatives

        optimizer.step()

    # Test network output after learning

    pred = network(data)

    print("loss after", nrepeat, "learning steps:", lossfn(pred, classes))

    print("first layer: weights = ", network[0].weight)

    print("first layer: bias = ", network[0].bias)

‍

3. Recopiez le code suivant à la fin du fichier Python et testez-le en appuyant sur le bouton « Réinitialiser l’IA » (vous pouvez voir les affichages des print dans la console).
4. Maintenant vous allez remplir les 3 fonctions init, learn et take_decision :

En haut du fichier définissez les variables suivantes qui seront accessibles dans les différentes fonctions

network = lossfn = optimizer = None

A l’intérieur de chacune des 3 fonctions rendez ces variables accessibles avec la ligne :

global network, lossfn, optimizer

Déplacez la partie « initialisation du réseau » dans la fonction init

Déplacez la partie « apprentissage » dans la fonction learn (mais supprimez la boucle for : ne mettez qu’une seule étape de l’apprentissage, sachant que la fonction sera appelée un grand nombre de fois)

Ecrivez la fonction take_decision, qui doit renvoyer le numéro de catégorie correspondant à l’entrée « sensors », c’est-à-dire 0 ou 1

5. Testez votre programme dans le logiciel, avec le robot simulé, puis avec le vrai robot !

Review and feedback

Nous espérons que cette séance vous a aidé à redécouvrir les réseaux de neurones de manière concrète !!

‍

En programmation, la liste des fonctions accessibles d’un programme s’appelle API, pour Application Programming Interface, Interface de Programmation d’Application. Elle est utilisée par les programmeurs pour savoir comment interagir avec le programme. Vous trouverez l’API du module python alphai en suivant ce lien : https://drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view

Introduction à l’IA - 4 niveaux d’autonomie

Contenu vidéo

Introduction

‍

‍

Éthique de l’IA

Contenu vidéo

Introduction

‍lien vers FAQ + intégration questions spécifiques liées à la page

Feedback (Was this page helpful ? Yes/No → si "No" alors pop-up)

Navigation (page suivante / précédente)

‍

TP à télécharger (prof et élève)

Related courses

‍

Proposez une activité !

AlphAI software lets you create completely customized configurations to suit your needs and objectives.

Choose a level of autonomy, an algorithm, the sensors and actions you want to use, ... and invent your own activity!
You can also start from an example configuration and then customize it.

Once you're happy with the configuration you've chosen, you can save it on your computer for future use!

Pour tout comprendre à la configuration du logiciel, suivez ce lien :
lien vers Page ressources - logiciel > Présentation du logiciel > Panneau fenêtre

Vous avez inventé une activité intéressante, ludique et pédagogique ?‍

Nous aimerions beaucoup l’essayer, et pourquoi pas la proposer à tous les utilisateurs du logiciel !

Merci de remplir le formulaire ci-dessous pour nous fournir les informations liés à l’activité que vous avez inventé : 

Activity proposal form : 

• Your first and last name : 
• Your function:
  
  
• Activity title : 
• Activity objective: 
• Minimum age for participation : 
• Estimated time required :
  
  
• Arena size and layout : 
• Type of robot used : 
• Number of robots used :
  
  
• Activity description: 
• Parameter file : 

Upload file (.json)

‍

Curriculum proposals

Elementary

Cursus “découvrir l’IA”

Objectifs : Se familiariser avec l’IA et les apprentissages
Temps nécessaire : environ 4h

Activities :

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (apprentissage supervisé uniquement)
3. Robot suiveur
4. Apprentissage par renforcement - Évitement d’obstacles

College

‍

Cursus “introduction complète à l’IA”

Objectifs : Comprendre le fonctionnement de base de l’IA et des apprentissages
Temps nécessaire : environ 6h

Activities :

1. Introduction à l’IA
2. Course de robots - introduction à l’apprentissage supervisé
3. Suivi de ligne (édition manuelle + apprentissage supervisé)
4. Robot suiveur
5. Apprentissage par renforcement - Évitement d’obstacles
6. Éthique de l’IA

‍

Cursus “introduction rapide à l’IA”

Objectifs : Comprendre le fonctionnement de base de l’IA et des apprentissages
Temps nécessaire : environ 3h

Activities :

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. Robot suiveur
4. Apprentissage par renforcement - Évitement d’obstacles

Lycée

Introduction to AI" curriculum

Objectifs : Comprendre le fonctionnement de base de l’IA et des apprentissages
Temps nécessaire : environ 5h

Activities :

1. Introduction à l’IA
2. Course de robots - introduction à l’apprentissage supervisé
3. Suivi de ligne (édition manuelle + apprentissage supervisé)
4. Apprentissage par renforcement - Évitement d’obstacles
5. Éthique de l’IA

‍

Cursus “IA & Mathématiques”

Objectifs : Comprendre le fonctionnement de l’IA et des apprentissages, et que tout est régit par des maths !
Temps nécessaire : environ 8h

Activities :

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. Algorithme KNN
4. Détection d’intrus (mathématiques des réseaux de neurones)
5. Apprentissage par renforcement - Évitement d’obstacles
6. Apprentissage par renforcement - Bloqué VS Mouvement

‍

Cursus “IA & Programmation python” simple

Objectifs : Comprendre le fonctionnement de l’IA et des apprentissages, et programmer les algorithmes en python
Temps nécessaire : environ 9h

Activities :

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. AlphAI télécommandé (programmation python)
4. Algorithme KNN
5. Algorithme KNN avancé (programmation)
6. Apprentissage par renforcement - Évitement d’obstacles
7. Apprentissage par renforcement - Bloqué VS Mouvement

‍

Cursus “IA & Programmation python” avancé

Objectifs : Comprendre le fonctionnement de l’IA et des apprentissages, et programmer les algorithmes en python
Temps nécessaire : environ 14h

Activities :

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. AlphAI télécommandé (programmation python)
4. Programmation caméra
5. Algorithme KNN
6. Algorithme KNN avancé (programmation)
7. Détection d’intrus (mathématiques des réseaux de neurones)
8. Apprentissage par renforcement - Évitement d’obstacles
9. Apprentissage par renforcement - Bloqué VS Mouvement
10. Apprentissage par renforcement - Q-learning (programmation)

‍

Cursus “Programmation python”

Objectifs : Savoir programmer des algorithmes simples en python
Temps nécessaire : environ 4h

Activities : 

1. AlphAI télécommandé (programmation python)
2. Programmation caméra

Supérieur

Cursus “IA & Programmation python”

Objectifs : Comprendre le fonctionnement de l’IA et des apprentissages, et programmer les algorithmes en python
Temps nécessaire : environ 16h

Activities : 

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. AlphAI télécommandé (programmation python)
4. Programmation caméra
5. Algorithme KNN
6. Algorithme KNN avancé (programmation)
7. Détection d’intrus (mathématiques des réseaux de neurones)
8. Programmation réseaux de neurones avec Scikit-learn
9. Apprentissage par renforcement - Évitement d’obstacles
10. Apprentissage par renforcement - Bloqué VS Mouvement
11. Apprentissage par renforcement - Q-learning (programmation)

Ce cours a été donné par Learning robots à Paris Saclay. Vous pouvez le retrouver ici.

‍

Cursus “IA”

Objectifs : Comprendre le fonctionnement de l’IA et des apprentissages
Temps nécessaire : environ 8h

Activities : 

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. Algorithme KNN
4. Détection d’intrus (mathématiques des réseaux de neurones)
5. Apprentissage par renforcement - Évitement d’obstacles
6. Apprentissage par renforcement - Bloqué VS Mouvement

‍

Cursus “Introduction à l’IA”

Objectifs : Comprendre les bases de l’IA et des apprentissages
Temps nécessaire : environ 4h

Activities : 

1. Course de robots - introduction à l’apprentissage supervisé
2. Suivi de ligne (édition manuelle + apprentissage supervisé)
3. Apprentissage par renforcement - Évitement d’obstacles
4. Apprentissage par renforcement - Bloqué VS Mouvement

‍

Cursus “Programmation python”

Objectifs : Savoir programmer des algorithmes simples en python
Temps nécessaire : environ 4h

Activities : 

1. AlphAI télécommandé (programmation python)
2. Programmation caméra

‍

Robot presentation

Introduction

‍

Thymio is an educational robot designed by researchers at EPFL, in collaboration with ECAL, and is very popular in colleges for teaching programming with Scratch.

Screenshot - thymio - preparation 1

‍

Thanks to our AlphAI software, teachers can now help their students discover and understand AI.

‍

In our activities, you will have the opportunity to train AI models in supervised or reinforcement learning, in order to carry out more complex tasks with the Thymio robot.

‍

Composition

Sensors

‍

The sensors you can use on the software are :

IR de proximité‍

Permet d’utiliser les 5 capteurs infrarouges à l’avant et les 2 capteurs infrarouges à l’arrière du robot.some text

• The first button lets you select which sensors you wish to activate: all, none, front sensors, rear sensors, central sensor, side sensors.
• The binary mode option allows you to obtain integer values 0 or 1 instead of decimal values between 0 and 1.
• When binary mode is active, the IR threshold parameter is used to set the switching threshold between binary values 0 and 1. For example, when the threshold is set to 0.5 (default value), all values between 0.5 and 1 are rounded to 1, and all values between 0 and 0.5 are rounded to 0.

‍

Suivi de ligne IR‍

• permet d’utiliser les 2 capteurs infrarouges de suivi de ligne, situés sous le robot. Ils communiquent une valeur entre 0 et 1 en fonction de la luminosité de la surface. Il y a deux modes principaux :some text
  • Black detection: value 0 corresponds to white and value 1 corresponds to black. Recommended for tracking a black line on a white background.
  • Détection de la réflexion : la valeur 0 correspond au noir et la valeur 1 correspond au blanc

‍

         The binary mode option allows you to obtain only integer values 0 and 1 instead of decimal values between 0 and 1.

• Lorsque le mode binaire est actif, le paramètre seuil IR permet de fixer le seuil de bascule entre les valeurs binaires 0 et 1. Par exemple, lorsque le seuil vaut 0.5 (valeur par défaut), toutes les valeurs entre 0.5 et 1 sont arrondies à 1, et toutes les valeurs entre 0 et 0.5 sont arrondies à 0.
  

‍

l’accéléromètre‍

• Permet d’utiliser le gyroscope du robot. Il communique une valeur pour chaque axe x (derrière - devant), y (gauche - droite) et z (en bas - en haut). Vous pouvez choisir un seul des axes, ou une combinaison.

‍

la caméra de l’ordinateur‍

• permet d’utiliser la webcam de l’ordinateur en tant que capteur. Plusieurs options sont proposées, qui déterminent la résolution de la caméra et l'utilisation ou non du zoom.

The camera image pre-calculation button is used to modify the processed values:

• when pre-calculation is deactivated, the image defaults to color (RGB system).
• grayscale mode captures the brightness of each pixel.
• the color mode in the image detects colors. All white/gray/black pixels will obtain the value 0 and colored pixels the value 1.
• green channel mode detects only the presence of green (values close to 1) or its absence (values close to 0).
• red vs. green mode returns a value between -1 and 1 for each pixel, corresponding to the amount of red minus the amount of green.

‍

• The take photo button lets you take a photo with the webcam and save it on your computer.
• The mirror effect option reverses or not the image (left-right axial symmetry).
• The camera index option lets you select which webcam to use when your device has more than one.

The actions

‍

The actions you can use on the software are :

• Movement:
  

‍

• Pivoting :
  

• Lighting :

‍

You can also create a custom action by clicking on the button: 

The following window will then appear: 

Name your action and check "robot action" to modify the parameters: the new action is now available.

‍

To save it for future use, click on File > Save > Save configuration.

‍

Operating environment

‍

Nous vous recommandons d’utiliser Thymio dans une arène AlphAI.

MOBSYA propose également des pistes robotiques dans lesquelles faire évoluer Thymio. Cependant, l’absence de murs limite les activités que vous pourrez réaliser.
Vous pouvez également faire simplement évoluer Thymio sur une surface plane.

‍

Pour réaliser l’intégralité des activités sur le logiciel, Thymio aura besoin de :

• A very flat surface, ideally covered with a tarpaulin
• Walls higher than the robot
• One or more lines on the ground in a color that contrasts sharply with the tarpaulin (you can use black tape).

All activities can be carried out with the simulated robot in Thymio Suite.

‍

Robot connection

‍

Wireless key with Thymio Suite

Premiers pas avec Thymio AI

‍Video - thymio - preparation 1

1. Open Thymio Suite
2. Connect the robot to your computer by plugging in the Wireless key (USB Dongle).
3. Switch on your Thymio robot
   (simply press and hold your finger on the circle in the center of the arrows until the robot makes a sound and turns green. This takes a few seconds.)
   When the robot is connected to the key on the computer, it starts flashing! 
4. Launch AlphAI software
5. Select the robot in the software home screen 
6. The main screen opens, and you can begin your activities!

⚠️ When you first connect to the robot, you will be asked for the software activation key number supplied with the robot.‍

Simulation with Thymio Suite

Video - thymio - preparation 2

1. Open Thymio Suite
2. Click on "Launch simulator" in the toolbar. Select the arena of your choice.
3. Launch AlphAI software
4. Select the simulated robot that appears on the software home screen

⚠️ Ideally, you'll need a second screen so that you can have the Thymio Suite and AlphAI software windows open simultaneously.

‍

Robot maintenance

Battery recharge (USB type A)

To recharge Thymio, simply plug it into a computer using the supplied micro-USB cable.

If your Thymio won't turn on even when connected to a computer, connect it to a wall charger.

When Thymio is charging, a red light comes on near the USB port). If it's on, the battery level LEDs will flash.

‍

Recurring problems

A help button on the Thymio suite redirects you to the Thymio help page: FAQ Thymio

‍

Robot update

1. Download and install the latest version of Thymio Suite.
2. Connect Thymio to your computer using the USB cable.
3. Launch Thymio Suite.
4. Launch VPL or any other programming language.
5. If an update is available, an update icon appears on the robot. Right-click on the robot you wish to update and select "update firmware", or simply click on the update icon.
6. Wait for the blue bar to fill up. Once it's full, the update is complete.

‍

Support / warranty

To validate your robot's warranty, you need to register it on the Thymio website. If you have any problems with your robot, please contact the Thymio support center.

Arena and track

If you own an AlphAI arena, please refer to this page to understand how to assemble it and the different possible layouts: 

link to AlphAI's resources page > Preparing the material > Setting up the arena

‍

Our partner MOBSYA offers a wide range of tracks to roll out on the floor, buy or print at home: https: //www.thymio.org/fr/ressources/ressource-dactivites/

‍

In each of the activities presented on this resource page, we've added a link to download the printable track where possible.

‍

Fearful Thymio

‍

‍

Recommended for hands-on learning.

Teach your robot to react to specific situations!In this activity, you'll learn how to set up the AlphaAI software and its neural network to operate Thymio in a simple environment.

This activity was designed with our partner MOBYSIA, makers of the Thymio robot.

‍

Objectifs

In this activity, we'll teach Thymio to react if something comes too close to him. Specifically, if its front and rear horizontal sensors detect an object, it will try to move away with its wheels. What's more, if he's surrounded on all sides and can't escape, he'll turn on himself.

Equipment set-up

Connectez votre robot à Thymio suite puis à AlphaAI. Posez le robot sur une surface plane, idéalement avec une bâche, dans un espace de 80 cm² minimum. Choisissez les paramètres correspondants à cette activité dans le logiciel AlphaAI

Première phase : observation

Allumez le bouton "autonome" et éteignez le bouton "apprentissage". Déplacez votre main devant les capteurs de proximité, avant et arrière. Que pouvons-nous constater ? Le comportement aléatoire du robot est normal : il n'a pas encore appris à réagir à la stimulation de ses capteurs.

Deuxième phase : apprentissage

Éteignez le bouton "autonome" et allumez le bouton "apprentissage".
À partir de maintenant, nos actions seront enregistrées pour réaliser l'entraînement de Thymio :

1. Approchez Thymio à un récepteur il y a quelque chose devant lui :
Placez un doigt devant le capteur central de devant et cliquez sur l’icône d’action flèche vers le bas.

2. Apprenez à Thymio à ne pas bouger si il n'y a rien :
En s’assurant que tous les capteurs infrarouges de Thymio soient à zéro, cliquer sur l’icône s’arrêter.

‍

‍

Troisième phase : autonomie

Maintenant, on peut tester si Thymio a bien appris !

Allumez le bouton “autonome” et éteignez le bouton “apprentissage”.

Placez votre doigt devant ses capteurs : est-ce que Thymio se comporte comme prévu ?

‍

Quatrième phase : apprentissage plus complet

Complexifions maintenant les réactions de Thymio en utilisant tous les capteurs disponibles.

Commencez par ajouter de nouvelles actions : reculer à droite, reculer à gauche, tourner à droite, tourner à gauche, avancer, et pivoter à 180°.
⚠️ Ajouter une nouvelle action supprimera la mémoire d’expérience du robot.

Éteignez le bouton “autonome” et allumez le bouton “apprentissage”.

Associez la stimulation de chaque capteur à une action spécifique, par exemple en suivant les instructions de ce tableau :

Une fois que toutes les réactions sont apprises à Thymio en fonction de chaque situation, allumez le bouton “autonome” et éteignez le bouton “apprentissage”.

Est-ce que Thymio se comporte comme prévu ?

Keeping track

‍

In this activity, we're going to teach Thymio to follow a line drawn on the floor, its aim being to make as many round trips as possible in the allotted time (2 to 3 minutes).

Equipment set-up

Connect your robot to Thymio suite and then to AlphAI.
Place the robot on a flat surface, ideally with a tarpaulin, and add a 60 cm long track. Create the track on a light-colored surface.

A track is also available in A2 format in the appendix on the right-hand side of this page.

○ ligne-noire-2xA3.pdf which can be printed on 2 A3 sheets to be joined together with adhesive tape.

○ ligne-noire-4xA4.pdf which can be printed on 4 A4 sheets and assembled in the same way.

Select the "supervised learning - line tracking" example configuration in the AlphAI‍ software.

Regulations

Several teams of 2 or 3 students compete, each choosing a name for the team and the robot.

A team places its robot at the start of the track. When the timer starts, the robot begins its journey. At the end of the allotted time, the number of outward and return journeys is added up, and the result recorded in a table.

If a participant's hand helps the robot, a 10-second penalty is deducted from the total course time.

For example, a helper will reduce the time from 2 min to 2 min -10 sec = 1 min 50 sec.

If the robot leaves the track without returning on its own, the current outward or return journey is not taken into account. The team may return the robot to the beginning of the section covered, but a 10-second penalty is applied.

If the robot turns around and returns to the track in reverse before reaching one of the ends, let it continue, but the outward or return journey in progress will not be counted.

There may be several rounds.

The winning team is the one whose robot has made the greatest number of round trips over all the rounds.

AlphAI settings

• Sensors tab

Use the ground IR sensors in value mode, unchecking the "binary_mode" box if you haven't already done so.
Capture ecran - thymio - activites 1

• Actions tab

The team is free to choose the actions to be used. They can also set the duration, pause and maximum speed parameters as they wish (trial runs are recommended). These 3 parameters can be modified without having to repeat the learning process.

• AI tab

⚠️Laisser default choices supervised learning and neural network. Do not modify learning speed. Possibly reduce it if the robot often makes mistakes.

Choose the combination 10 20, i.e. 2 layers of neurons, one of 10 and the next of 20.

It's up to you to lead the learning process. Make sure you consider all possible cases - there aren't too many of them. If you wish, you can save your settings in the menu Settings > Save settings ...

‍

Solutions (->Help)

‍

‍

On your marks!

Equipment set-up

Réaliser un cercle de diamètre de 60cm sur la bâche avec le scotch noir, ne pas hésiter à doubler l’épaisseur du cercle à 4-5 cm. Disposer à l'intérieur du cercle le robot Thymio ainsi que 4 ou 5 petits objets. Caractéristiques des objets : Ces objets doivent être assez légers pour être déplacés par Thymio. Ils peuvent être de forme quelconque mais avoir une couleur claire pour renvoyer les rayons infrarouges des capteurs. Leur largeur doit être comprise entre 2 et 9 cm environ. Exemple : des gobelets, des éléments lego, de petits cubes de bois …‍

Objective

No, we're not turning Thymio into a vacuum cleaner! Thymio will simply be in charge of pushing all objects outside the circle, as shown in the figure below:

‍

What Thymio has to do

We're going to teach Thymio what to do using the method we discovered in the previous activity, "Thymio the Fearful", the supervised learning method.Recall that in supervised learning, we looked at the values of his sensors, then told Thymio the action to perform.We had studied only a few important situations. Thanks to the neural network, Thymio had learned what to do in situations it had never encountered before.‍

A first simulation by hand‍

À l'intérieur du cercle noir, disposer quelques objets au hasard et placer également Thymio. Il faut simuler à la main ce que doit faire le robot pour pousser les objets hors du cercle. Mais attention, il faudra respecter quelques consignes. Sinon nos idées ne pourront pas être utilisées dans le programme. Vérifier que les actions imaginées sont bien présentes dans l'onglet Actions du logiciel Alphai. L'action à exécuter dépendra toujours des valeurs des capteurs. Il faudra donc bien imaginer ce que captent les capteurs. En particulier, pour un état des capteurs, ne pas proposer plusieurs actions différentes.
Par exemple, mettons que si le capteur central capte quelque chose, vous lui demandez d'avancer : ne pas lui proposer plus tard de tourner à droite si à nouveau le capteur central capte quelque chose. Prendre le robot à la main. Le premier mouvement sera d'avancer le robot tout droit sur un petite distance, 3 ou 4 cm. Puis pousser un objet hors du cercle. Vous pouvez prendre la situation décrite dans la figure précédente où Thymio va toucher l'objet mauve par le côté. Déterminer les actions à effectuer en fonction des informations des capteurs. Une fois la situation bien analysée, vous pouvez éventuellement tenter de la reproduire avec Alphai, en ajoutant des actions si nécessaire.

‍Gettingorganized

‍Pour bien retenir quelle action faire, en regardant l'état des capteurs, il est pratique d'utiliser un tableau. On s'aidera donc du tableau donné en Annexe 2 en le remplissant de la manière suivante : Dans la première colonne, indiquer ce qu'il y a autour ou dessous Thymio. Dans les colonnes capteurs.

• if the sensor picks something up, put a cross
• if he doesn't get anything, put a hyphen
• if it doesn't matter what it picks up, put a question mark.

Dans la colonne actions, mettre l'action correcte. Une fois que vous avez trouvé comment faire pour pousser un objet hors du cercle, trouvez comment utiliser le cercle noir pour renvoyer Thymio à l'intérieur du cercle. Puis poursuivre la simulation à la main jusqu'à avoir poussé tous les objets [1]. Remarque : pour compléter le tableau, il y a plusieurs solutions possibles [2] et vous n'êtes pas obligés d'utiliser toutes les lignes. Enfin, réaliser l'apprentissage complet, passer en mode autonome et contempler Thymio en train de pousser tous les objets hors du cercle ! Réglage final des actions et solutions possibles en annexe 3.

_{‍[1] Il peut être intéressant de filmer le 'nettoyage' fait à la main avec une webcam et le visionner ensuite pour que le groupe puisse vérifier si le robot pourra vraiment effectuer tous les mouvements faits par la main.}

_{[2] Une solution qui voudrait envisager tous les cas possibles avec 7 capteurs (5 horizontaux et 2 dessous) devrait étudier au minimum 128 situations différentes !}

‍

‍Rappel pour connecter Thymio*Annexe et Appendix (solution->Aide) 

Appendix (solution->Help) 

First tab settings

Onglet capteurs

Choisir les capteur IR de proximité, et les capteur IR de suivi de ligne en valeurs.

Actions tab

AI tab

‍

Solutions possibles

Seul l'onglet Actions a besoin de subir des modifications.

10 actions au total.

Légende:

X : quelque chose devant

- : rien en vue

On notera que les capteurs arrière gauche et droit ne sont pas du tout sollicités. On peut donc tout simplement ne pas les utiliser : pour cela, dans l’onglet Capteurs choisir IR de proximité / choix des capteurs : capteurs avant.

The autonomous car

‍

Recommandé pour approfondir l’apprentissage supervisé

Apprenez à votre robot à effectuer des tâches précises grâce à l’apprentissage supervisé. Cette dernière activité permet de réunir tout ce qui a été vu au cours des dernières activités d’apprentissage supervisé. Elle réunit les détections d’obstacles, demi-tours et suivi de ligne.

‍

Equipment set-up

Un parcours d'exemple est donné en Annexe 1. Les murs sont aux dimensions d'une feuille A4 pliée en 4 sur la longueur.

‍On peut réaliser des murs à peu de frais avec des feuilles A4 et un rouleau de ruban adhésif.

Mur long : plier une feuille A4 3 fois dans le sens de la longueur. L’aplatir et coller les 2 côtés opposés avec un morceau d’adhésif, puis lui redonner son volume en 3D (forme de barreau). La dimension est donc de 297 x 52 x 52 mm.

Si la section d'un mur ne se maintient pas carrée, on peut la renforcer en glissant un autre mur plié en équerre (angle droit).

Mur court : Il suffit de couper un mur long quand il est aplati.Dimension : 145 x 52 x 52.

‍La disposition proposée utilise 9 feuilles : mur long et 3 feuilles de mur court.

Évitez un sol trop rugueux ou bosselé.

The challenge

Dans cette activité, Thymio doit endosser le rôle d'une voiture autonome parcourant une rue.

La rue est simulée par une série de murs parallèles, dessinant un parcours sinueux. A la fin de la rue, on place une ligne noire perpendiculaire aux murs des extrémités.

Le robot doit parcourir la rue sans toucher les murs. Une fois arrivé à la fin de la rue, il fait demi-tour et parcourt la rue en sens inverse.

Enrichissements possibles : Simulation d'un piéton. On place au moment de son choix un obstacle, de largeur maximum de 6 cm environ, au milieu de la rue pour simuler le piéton. Thymio doit s'arrêter devant. On retire le piéton, Thymio redémarre et poursuit son parcours.

On peut reprendre les règles du jeu présentées dans l' activité : “ Garder la piste”. Si cette dernière activité a déjà été faite sous forme de jeu , on peut combiner les scores des deux activités.

‍
Ajout du piéton avec ou sans pause 

• 1st strategy

If all 3 central sensors pick up, stop. If only the central sensor picks up, stop.
Works well with a pedestrian, but stops in front of a wall.

• 2nd strategy

If the sensor in the center picks it up, stop.
Works well with a well-placed narrow pedestrian, better with a wall in front, but sometimes wrong.

AlphAI settings

Onglet Capteurs:

Les capteurs de proximité et les capteurs IR sol seront utilisés.

Onglet Actions:

The team is free to choose the actions to be used. They can also set the duration, pause and maximum speed parameters as they wish (trial runs are recommended). These 3 parameters can be modified without having to repeat the learning process.

Onglet AI :

Laisser les choix par défaut apprentissage supervisé et réseau de neurones. Ne pas modifier la vitesse d'apprentissage. Éventuellement la diminuer si le robot se trompe souvent. Choisir la combinaison 10 20, soit 2 couches de neurones, une de 10 et la suivante de 20. À vous de mener l'apprentissage. Attachez vous à envisager tous les cas possibles, ils ne sont pas très nombreux. Vous pouvez enregistrer vos paramètres dans le menu Paramètres > Sauver les paramètres ...

Appendices

Apprentissage

Solutions

‍