Découvrez nos
ressources

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 !

‍

‍

‍

‍

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 !

‍

‍

‍Bilan et retours d'expérience

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