IMA4 2018/2019 P35

Présentation générale

Nom du projet : Machine Learning pour navigation autonome de robots mobiles

Résumé : Le but du projet est de permettre le robot trouver un trajectoire optimale

Etudiants : Wenjing CHEN et Puyuan LIN

Description

L'apprentissage automatique (en anglais machine learning ) est un champ d'étude de l'intelligence artificielle qui se fonde sur des approches statistiques pour donner aux ordinateurs la capacité d' « apprendre » à partir de données, c'est-à-dire d'améliorer leurs performances à résoudre des tâches sans être explicitement programmés pour chacune. Plus largement, cela concerne la conception, l'analyse, le développement et l'implémentation de telles méthodes.

Dans notre projet, l'apprentissage automatique est appliqué aux robots, en prenant des données personnalisées en entrée et en donnant le comportement d'action du robot en sortie dans le cas correspondant. Nous fournissons un ensemble de données d'entrée / sortie pour le robot. Le robot apprend le jeu d'entrées / sorties pour obtenir le modèle du calcul lui-même. Le robot peut donc utiliser ce modèle pour réaliser une navigation autonome.

Nous allons traiter ce projet avec la navigation autonome de robots, qui n'inclut pas le positionnement du robot et n'utilise pas de capteurs pour détecter les obstacles. La taille et la limite (mur) de la carte que nous utilisons sont fixes, mais la position de l'obstacle change. Nous utiliserons des réseaux de neurones pour identifier l'emplacement des obstacles et prévoir l'itinéraire optimal.

Objectifs

robotino

Dans le but de réaliser notre projet nous devrons remplir les objectifs suivants:

• Nous devons apprendre et utiliser python pour programmer le robot afin de réaliser la fonction de machine learning, afin que le robot puisse trouver le meilleur itinéraire.

• Nous devons apprendre et utiliser TensorFlow pour apprendre le machine learning.

• Nous devons apprendre et utiliser Intel Neural Compute Stick pour calculer nos base de donnée.

Analyse du projet

Positionnement par rapport à l'existant

Il existe actuellement une grande tendance de robots mobiles de navigation autonome, dont certaines utilisent la carte intégrée pour atteindre la destination, tandis que d’autres obtiennent le chemin en avant via le code à barres attaché au sol. Mais pour éviter les obstacles, il s’agit essentiellement de capteurs pour surveiller les obstacles environnants.

Analyse du premier concurrent

Aethon Robot

Aethon Inc，un fournisseur mondial de robots de transport mobiles autonomes, a été fondé en 2001.Sa technologie principale comprend les robots mobiles automatiques（TUG）. Le TUG est un robot mobile autonome et intelligent doté de devenir une phénomène normale dans les hôpitaux car il délivre matériaux et fournitures. TUG livre efficacement des chariots de fournitures là où ils sont nécessaires, y compris les repas, linge de maison, ainsi que l'enlèvement des ordures.Contrairement aux autres robots de navigation autonomes, il utilise des cartes intégrées et une gamme de capteurs embarqués pour la navigation. Les développeurs utilisent des cartes de haute précision des installations hospitalières, puis programment leur agencement, y compris l’utilisation des ascenseurs, l’ouverture automatique des portes, les points de livraison et les stations de recharge. La carte programmée est chargée dans la mémoire du TUG. TUG utilise des cartes embarquées à des fins de guidage et calcule sa position en temps réel à l'aide de l'algorithme d'odométrie breveté d'Aethon. Il utilise des capteurs embarqués pour ajuster les corridors dynamiques et changeants en temps réel, naviguant en toute sécurité autour des personnes et des obstacles, tout en utilisant toujours sa carte intégrée pour le suivi.

https://aethon.com/products/

Analyse du second concurrent

Kiva Robot

Amazon Robotics, anciennement Kiva Systems, est une entreprise du Massachusetts qui fabrique des systèmes d'exécution robotiques mobiles. Traditionnellement, les marchandises sont déplacées autour d’un centre de distribution à l’aide d’un système de convoyage ou de machines actionnées par l’homme (comme des chariots élévateurs). Dans l’approche de Kiva, les articles sont stockés sur des unités de stockage portables. Lorsqu'une commande est validée dans le système de base de données Kiva, le logiciel localise le robot mobile le plus proche de l'article et lui ordonne de le récupérer. Les robots mobiles naviguent dans l’entrepôt en suivant une série d’autocollants de codes à barres informatisés posés au sol. Chaque unité d’entraînement est équipée d’un capteur qui l’empêche de se heurter aux autres. Lorsque l'unité d’entraînement arrive à l'endroit objectif, elle glisse sous la nacelle et la soulève du sol grâce à un tire-bouchon. Le robot transporte ensuite la nacelle vers l'opérateur pour prendre les articles.

Kiva a deux modèles de robots. Le plus petit modèle mesure environ 2 pieds sur 2,5 pieds et un pied de haut et peut soulever 1 000 livres. Le plus grand modèle peut transporter des palettes et des charges pesant jusqu'à 3 000 livres. La vitesse maximale d'un robot est de 1,3 mètre par seconde. Les robots mobiles sont alimentés par batterie et doivent être rechargés toutes les heures pendant cinq minutes.

https://www.amazonrobotics.com/

Scénario d'usage du produit ou du concept envisagé

• Nos produits sont adaptés à les entreprise logistiques ou les entreprises de commerce électronique. Le robot peut traiter lui-même la commande afin de terminer la livraison des marchandises, en réduisant les coûts de main-d'œuvre et en améliorant l'efficacité.

• Nos produits conviennent également à la gestion des entrepôts de l'entreprise.

• La perspective de cette voiture intelligente peut également être utilisée dans les futures voitures intelligentes. Nous pouvons planifier le point de départ et la destination de la voiture, puis la voiture fonctionne de manière autonome pour éviter les obstacles et atteindre la fin.

Réponse à la question difficile

Est-ce qu'on commence à zéro ou utilise des bibliothèque?

Nous n'avons pas besoin d'écrire le programme entier à partir de zéro. Parce que ce sujet est assez grand, il peut se diviser en plusieurs parties, par exemple la partie de création de la carte d'endroit, la partie de connaissance des obstacles statiques, la partie de détections des gens et des robots, la partie de navigation, etc. C'est difficile pour nous de réaliser tous pour le temps limité. Tout ce que nous devons faire est de réaliser un algorithme de machine learning pour réaliser un seul but, la navigation autonome. Pour les restes, nous pouvons utiliser les code précédent pour apporter des améliorations en fonction de cela.

Est-ce que la mémoire de robot est assez suiffissant pour stocker le base de donnée de machine learning?

La taille de la mémoire de robot n'arrive pas à réaliser nombreux de calcul， nous devons utiliser intel neural compute stick pour calculer et stocker des données.

Préparation du projet

Cahier des charges

Le robot mobile autonome devra réaliser:

• Générer une trajectoire automatiquement selon le point de départ et la destination par lui-même.

Phase d'apprentissage

• Prise de connaissance de machine learning et familiarisation avec l'environnement Tensorflow.
• Prise de connaissance de langage de programmation (Python).
• Prise de connaissance du principe d'algorithme dans le domaine de machine learning.

Techniques Logicielles

• Utilisation de Tensorflow.
• Utilisation de Python.

Liste des tâches à effectuer

• Conception du schéma global des différentes parties :
  • Apprentissage des logicielles (programmable, robotique)
  • Génération de trajectoires avec un réseau de neurone
  • Exécution de trajectoire
  • Validation du modèle

Réalisation du Projet

Feuille d'heures

Tâche	Prélude	Heures S1	Heures S2	Heures S3	Heures S4	Heures S5 + vacance	Heures S6	Heures S7	Heures S8	Heures S9	Heures S10	Total
Analyse du projet	4	4	2	2	1	0
Analyse de la structure de donnée d'entrée et sortie	0	0	3	2	1	1
Installation du Tensorflow et Python	0	0	0	0	3	0
Analyse de la modèle du reseau de neurone	0	0	0	5	0	5
Programmation de Tensorflow	0	0	0	0	0	4.5
Rédaction du wiki	3	1	0.5	0.5	0.5	1
Total de la semaine (heure)	8	5	5.5	9.5	5.5	11.5

Semaine 1

Cette semaine nous avons commencé nos recherches sur machine learning et avons essayé de comprendre le principe de la palteforme «Tensorflow». Nous avons determiné nos prochaines étapes：

• 1.Exploration de données: Connaître la format des données d'entrées et sorties.

• 2.Préparation de données: Transformer des données en format standard(Tous les tableaux entiers sont en même taille.)

• 3.Construire une modèle.

• 4.Former la modèle: Utiliser des échantillons pour la formation.

• 5.Evaluer la modèle: Calculer taux de précision en utilisant l'ensemble du test

Semaine 2

Avec l'aide de Monsieur Vincent Coelen, nous avons déterminé comment collecter des données pour entraîner la modèles de machine learning. On veut utiliser la simulation qu'il fournit la carte virtuelle dont nous avons besoin et le robotino peut s'y déplacer pour simuler l'itinéraire de navigation. Nous utilisons la manette externe pour contrôler le mouvement du robotino. On utilise cette méthode pour collecter des données. Après avoir les données, il faut utiliser l'autre logicielle pour les stocker.

Semaine 3

Cette semaine, nous avons analysé de la structure de la donnée qu'on nous devons collecte. Nous avons décidé de collecter la vitesse de l'abscisse, la vitesse de l'ordonnée et la vitesse angulaire de chaque point sur une trajectoire, afin de pouvoir relier tous les points en une trajectoire entier. En même temps, il faut noter les coordonnées du point de départ et la destination.

Semaine 4

• Initiation au Deep learning. Suivre le lien [1] pour avoir accès à des cours et des travaux pratiques centrés sur l'apprentissage approfondi.
• Pour installer Anaconda : [2]
• Pour installer PyTorch : [3]
• Pour installer Tensorflow : [4]

Semaine 5

Nous avons décidé notre méthode pour construire notre modèle de machine learning avec l'aide de Monsieur Vincent Coelen.

• Nous utilison le simulateur et la manntte pour collecter toutes les données dont nous avons besion. Ils se composent des points de départ, des points de destination et de tous les points de vitesse chaque 0,1 seconde (la frèquence du simulateur = 10Hz). Parce qu'on pilote le robot jusqu'à la destination munuellement, nous devons donc le contrôler artificiellement pour choisir la trajectoire optimale et supprimer les chemins qui sont loin du meilleur.
• Ensuite, lors de la phase d’entraînement, nous fournissons les trajectoires que nous collectons au réseau de neurones. Grâce à ce processus de formation, le robot peut apprendre à identifier l'emplacement de l'obstacle, tout en apprenant également à prédire la vitesse. Après la modèle est finie, il faut évaluer la fidélité de la modèle. On a décidé d'utiliser l'algorithme du gradient pour augmenter la fidélité petit-à-petit.
• Enfin, dans la phase d'utilisation, on fournit le point de départ et la destination comme les entrées, et par ailleurs, on aussi donne les premiers 10 points de vitesse pour arriver à la destination comme les entrées. Donc le réseau peut utiliser ces conditions et calculer pour continuer à deplacer pas-à-pas (1 point) jusqu'à la destination. Bien sûr, si nous plus de points comme l'entrée, la précision sera meilleure. Nous avons temporairement fixer à 10 points. Le robot va sûrement s'arrêter pour calculer le point suivant. Mais le temps est très court. Donc on pense qu'on peut le négliger.

Semaine 6-7

Nous avons commencé la semaine avec un rendez-vous avec notre tuteur afin de faire un compte rendu du simulateur de robotino. On lancer logiciel Rviz et utilise la mannette pour piloter notre robot.La vitesse et la vitesse angulaire à cet instant sont enregistrées automatiquementtoutes toutes les 0,01 secondes. Chaque fois on pilote le robot jusqu'à la destination, la prochaine destination apparaîtra au hasard sur la carte et ensuit on ferme l'acquisition, et toutes les données sur cet itinéraire seront automatiquement enregistrées sous forme de texte, Il faut faire attention que les données de la prochaine destination seront enregistrées aussi à ce moment-là, n'oubliez pas de supprimer. Parce que nous utilisons la mannette pour collecter manuellement des données, nous ne pouvons que contrôler le robot suive l'itinéraire optimal approximatif. Si parfois l'itinéraire que nous empruntons et que les meilleurs itinéraires sont éloignés, nous devons supprimer cette itinéraire inutiles.

Pour réaliser toutes les fonctions, il faut lancer 6 terminaux (droite à gauche).

• Le premier et le deuxième terminal sont d'ouvrir refbox.

 dans le 1er terminal:                  
                  cd refbox/rcll-refbox/
                  bin/llsf-refbox
 dans le 2ème terminal:
                  cd refbox/rcll-refbox/
                  bin/llsf-refbox

• Le troisième terminal est d'ouvrir l'environnement de simulateur et lancer le fichier de simulateur.

                  roslaunch gazebo_sim_launch env_global.launch sim:=true
                  roslaunch ML_acquisition StartAcquisition.launch

• Le quatrième terminal est d'ouvrir la carte virtuelle dont on a besoin.

                  rviz
                  load config ~/.rviz/ML_acquisition.rviz

• Le cinquième terminal est de connecter entre PC et la mannette. Et on ne contrôle qu'un robotino (robot 1).

                  launch the joystick controller
                  roslaunch robotino_teleop joystick_teleop.launch robot:=robotino1

• Le sixième terminal est d'engistrer toutes les données dans un texte.

                  cd ~/acquisition
                  rosrun ML_acquisition GenerateWaypoints1.py

Quand on ouvre la logicielle rviz, on peut trouver différents types de carte. La première carte simule l'environnement réel. Les rectangles représentent les obstacles. Le cercle représente le Robotino. On peut aussi voir une flèche rouge sur la carte, qui représente le point de destination et sa direction. Alors, il y a l'autre type de la carte. Il nous semble que les obstacles ont les couches épaissies. La fonction de cette couche est d'éviter la collision entre le Robotino et l'obstacle. Parce que l'épaisseur de la couche est supérieure à le rayon du Robotino. On peut aussi trouver que quelques lignes vertes apparaissent sur les obstacles. Ces lignes servent à représenter le contour de l'obstacle mesuré par le capteur de distance. En comparant ces deux types, nous avons finalement choisi le dernier pour collecter des données. Car on n'a pas besoin de s'inquiéter la situation de la collision. Donc, on peut obtenir les données qui est proche de la trajectoire optimale.

On utilise une manette sans fil pour simuler l'opération du Robotino dans la situation réelle. Quand on a fini une trajectoire, on doit arrêter le simulateur. Et nous devons traiter les données (supprimer les point de départ répétés et les point qui appartiennent au point de destination suivant). Enfin, on doit collecter au moins de 50 groupes de données qui peuvent permettre construire le réseau de neurones.

Semaine 8

Nous a a essayé de programmer la première partie: lire les données qu'on a déjà collecté; enregistrer dans le tensorflow et définir les groupes d'entraînement et les groupes de test. En fin, on doit réaliser la normalisation des données:

On a utilisé quelques bibliothèques:

  import tensorflow as tf                                 
  import matplotlib.pyplot as plt                   # pour dessiner les trajectoires
  import numpy as np
  import pandas as pd                               # pour qu'on peut utiliser les tableaux                                                                               
  import time

D'abord, on a définit une fonction pour lire des documents:

  def load_data(input_file):
      print("Load Data:\n")
      dataset = np.loadtxt(input_file, delimiter=",") 
      print("Done")
      print(len(dataset))
      return dataset
      train_targets = []                            #Créer un tableau pour entraînement
      test_targets = []                             #Créer un tableau pour test
      for n in [15]:
         train_data = dataset[15:, :14]                                                                                                      
         test_data = dataset[:15, :14]
         train_target = to_categorical(dataset[15:, n], num_classes=4)  
         test_target = to_categorical(dataset[:15, n], num_classes=4) #Pare qu'on a 4 types de données (point de départ, point de vitesse, point de destination et 
                                                                      image de carte ), donc 'num_classes' égale à 4
         test_targets = dataset[15:, 5:]
         test_targets = test_targets.astype(int)    #on change le type de label en entier

Lorsque différentes caractéristiques sont regroupées, les petites données en valeur absolue sont «consommées» par les méga données en raison de l'expression de la caractéristique elle-même. À ce stade, nous devons extraire "features vector". Normalisation s'assure que chaque caractéristiques est traitée de manière égale par le classificateur. Il y a beaucoup de méthode pour normaliser les données. On choisit une méthode classique: scikit-learn (StandardScaler):

       mean = train_data.mean(axis=0)
       train_data -= mean
       std = train_data.std(axis=0)
       train_data /= std
       test_data -= mean
       test_data /= std
       train_targets.append(train_target)
       test_targets.append(test_target)
       return train_data, train_targets, test_data, test_targets  

Ensuite, on doit enregistre les données dans un tableau et enregistrer le tableau dans un nouveau csv document:

  def readwrite(input_file,output_file):
      data_f=pd.read_csv(input_file,names=['StaX', 'StaY', 'StaA',          
                                           'VelX', 'VelY', 'VelA',
                                           'EndX', 'EndY', 'EndA', 'image'],sep=',')
      print(type(data_f), '\t', data_f.shape)
      data_f[['StaX', 'StaY', 'StaA', 
              'VelX', 'VelY', 'VelA',
              'EndX', 'EndY', 'EndA']].to_csv(output_file, sep=',', header=False,index=False)

Semaine 9

Nous souhaitons réaliser deux fonctions principales: laisser le robot reconnaître les obstacles sur la carte et naviguer une trajectoire correcte. Nous devons donc créer deux réseaux neuronaux pour permettre aux robots d’apprendre ensemble. Notre tâche cette semaine est de construire le premier réseau pour identifier les images. Nous avons décidé de le mettre en œuvre en utilisant un réseau neuronal convolutif. En apprentissage automatique, un réseau de neurones convolutifs ou réseau de neurones à convolution (en anglais CNN ou ConvNet pour Convolutional Neural Networks) est un type de réseau de neurones artificiels acycliques (feed-forward), dans lequel le motif de connexion entre les neurones est inspiré par le cortex visuel des animaux. Les neurones de cette région du cerveau sont arrangés de sorte qu'ils correspondent à des régions qui se chevauchent lors du pavage du champ visuel. Leur fonctionnement est inspiré par les processus biologiques, ils consistent en un empilage multicouche de perceptrons, dont le but est de prétraiter de petites quantités d'informations. Les réseaux neuronaux convolutifs ont de larges applications dans la reconnaissance d'image et vidéo. https://fr.wikipedia.org/wiki/R%C3%A9seau_neuronal_convolutif

Le principe de notre projet que nous avons conçu suivant:

D'abord, nous transformons l'image de la carte en une groupe de données, utilisant une bibliothèque de tensorflow. Et ensuite, nous devons calculer les convolutions de les données, et comme l'entrée de la fonction d'activation, et les mettre dans le pool et choisir la valeur maximal ou moyenne,après les mettre dans différent labels.

Les programmes principaux:

Nous devons d'abord récupérer les données contenant les informations des cartes :

 def load_imdata(input_file):
     image_datas = []
     X_im = []
     pathDir_1 =  os.listdir(input_file)                # retourner une liste de noms des fichiers dans le document 'input_file
     for allDir_1 in pathDir_1:
         child = os.path.join('%s/%s' % (input_file, allDir_1)) # connecter entre le document 'input_file' et les fichiers 
                                                                    pour devenir un sous-chemin d'accès,  par exemple :child =  'input_file/nom_de_fichier'
         df=pd.read_csv(child)                           # lire le fichier
         image_datas.append(df)                          # ajouter des nouveaux données à la fin de la liste      
     for data in image_datas:
         # print(data.shape)
         x = data.values.reshape(-1, data.shape[0], data.shape[1], 1).astype('float32') / 255.   # reconstituer la liste précédente pour que nous pouvons 
                                                                                                   transformer la liste en une forme matricielle
     X_im.append(x)
     print(len(X_im))
     # X_im = np.array(X_im)
     return X_im

Pour construire notre réseau CNN:

 class CNN:
     @staticmethod                            # La fonction intégrée @staticmethod retourne une méthode statique pour une fonction donnée.
     def build(input_shape):
         input = Input(shape=input_shape)
         x = Conv2D(64, (3, 3))(input)             #Conv2D pour la convolution d'images
         # x = Conv2D(128, (3, 3))(x)
         x = MaxPooling2D((2, 2))(x)               #définir Max pooling avec un filtre 2 × 2
         # x = Conv2D(256, (3, 3))(x)
         x = Flatten()(x)                                    # renvoie une copie de tableau réduit en une dimension.
         # x = Dense(16, activation='relu')(x)
         # x = Dropout(0.1)(x)
         x = Dense(1, activation='sigmoid')(x)
         return Model(input,x)
 model = CNN.build(input_shape)
 sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)    # créer un optimiseur de descente de gradient stochastique
 model.compile(
           loss='categorical_crossentropy',
           optimizer=sgd,
           metrics=['accuracy'])
 H = model.fit(
           x=train_data,
           y =train_targets,
           epochs=EPOCH,
           batch_size=1)

Ensuite nous avons utilisé LSTM/RNN pour prédire la trajectoire. Enfin, il faut combiner les deux réseaux pour qu'ils peuvent entraîner ensemble:

def train_model():
   print("Train Begin:")
   train_data, train_targets, test_data, test_targets = load_imdata('images_data')
   vel_X, vel_Y, vel_A = get_vel("vel_data")
   coord_marix = load_sf("data")
   x_train_img = train_data[0]
   x_train_img = x_train_img.reshape((-1,199,320,1))
   x_train_img = np.tile(x_train_img, (64, 1, 1, 1))
   print(x_train_img.shape)
   x_train_coor = coord_marix[0]
   print(x_train_coor.shape)
   y_train = vel_X
   print(y_train.shape)
   input_shape_img = (199, 320, 1)
   input_init_img = Input(shape=input_shape_img)
   input_shape_coor = (100,)
   input_init_coor = Input(shape=input_shape_coor)
   processed_img = CNN.build(input_init_img)
   processed_coor = input_init_coor    
   merged_layer = Concatenate(axis=-1)([processed_img, processed_coor])
   x = Dense(600)(merged_layer)
   print("before:",tf.shape(x))
   my_reshape = Lambda(lambda x: K.reshape(x, (-1,600,1)))
   x = my_reshape(x)
   print("after:",tf.shape(x))
   x = LSTM(128, input_shape=(600,1), return_sequences=True)(x)
   out = TimeDistributed(Dense(1))(x)
   model_X = Model([input_init_img,input_init_coor], out)
   model_X.summary()
   model_X.compile(loss='mean_squared_error', 
               optimizer='adam', # rmsprop
               metrics=['mae', 'acc']) #metrics=['accuracy']
   history = model_X.fit([x_train_img,x_train_coor], y_train,
           batch_size=20,
           epochs=EPOCHS,
           
           ) 
   model_X.save("my_model/X_vel_model.h5")
   prediction = model_X.predict([x_train_img,x_train_coor])
   print(prediction[0])
   ...
   # C'est le même principe pour construire la modèle d'entraînement pour Y et A.

Semaine 10

Après avoir entraîné nos réseaux, nous essayons de tester. Mais le résultat n'est pas satisfait : Pour la prédiction du point de vitesse dans la direction de l'axe X, les points prédits pendant la période précédente est précise, mais il existe un écart très large entre la valeur prédite et la valeur réelle. Également, les prédiction du point de vitesse dans la phase d'angle et la directions de l'axe Y ne sont pas raisonnables. Donc nous avons considéré de changer notre réseau en utilisant à prédire des trajectoires.

class LSTMRNN(object):    
   def __init__(self, n_steps, input_size, output_size, cell_size, batch_size):        
       self.n_steps = n_steps        
       self.input_size = input_size        
       self.output_size = output_size        
       self.cell_size = cell_size        
       self.batch_size = batch_size        
       with tf.name_scope('inputs'):            
           self.xs = tf.placeholder(tf.float32, [None, n_steps, input_size], name='xs')            
           self.ys = tf.placeholder(tf.float32, [None, n_steps, output_size], name='ys')        
       with tf.variable_scope('in_hidden'):            
           self.add_input_layer()       
       with tf.variable_scope('LSTM_cell'):            
           self.add_cell()        
       with tf.variable_scope('out_hidden'):            
           self.add_output_layer()        
       with tf.name_scope('cost'):            
           self.compute_cost()        
       with tf.name_scope('train'):            
           self.train_op = tf.train.AdamOptimizer(LR).minimize(self.cost)
        ...

Définition de couche d'entrée:

   def add_input_layer(self,):        
       l_in_x = tf.reshape(self.xs, [-1, self.input_size], name='2_2D')        
       Ws_in = self._weight_variable([self.input_size, self.cell_size])              
       bs_in = self._bias_variable([self.cell_size,])            
       with tf.name_scope('Wx_plus_b'):            
           l_in_y = tf.matmul(l_in_x, Ws_in) + bs_in        
           # reshape l_in_y ==> (batch, n_steps, cell_size)        
           self.l_in_y = tf.reshape(l_in_y, [-1, self.n_steps, self.cell_size], name='2_3D')     

Définition de couche de sortie

   def add_output_layer(self):        
       l_out_x = tf.reshape(self.cell_outputs, [-1, self.cell_size], name='2_2D')        
       Ws_out = self._weight_variable([self.cell_size, self.output_size])        
       bs_out = self._bias_variable([self.output_size, ])        
       # shape = (batch * steps, output_size)        
       with tf.name_scope('Wx_plus_b'):            
           self.pred = tf.matmul(l_out_x, Ws_out) + bs_out     

Définition la fonction de perde:

   def compute_cost(self):        
       losses = tf.contrib.legacy_seq2seq.sequence_loss_by_example(            
           [tf.reshape(self.pred, [-1], name='reshape_pred')],            
           [tf.reshape(self.ys, [-1], name='reshape_target')],            
           [tf.ones([self.batch_size * self.n_steps], dtype=tf.float32)],            
           average_across_timesteps=True,            
           softmax_loss_function=self.ms_error,            
           name='losses'        
           )

Semaine 11

Nous avons rencontré le même problème que nous avons la semaine dernière. Après avoir discuté avec nos profs, ils ont proposé plusieurs de solutions pour nous:

• 1. Dans le réseau 'CNN', lors du processus de transformation des cartes en données, nous convertissons toujours en valeur fixe (0) pour la partie sans obstacle, et les données de cette partie peuvent être négligées. Nous ne pouvons enregistrer que des informations sur les obstacles (telles que la position, la taille, la forme) afin d’équilibrer entre les données de la carte et celles du trajectoires.
• 2. Il y a peut-être un problème sur la connexion entre les deux réseaux.
• 3. La troisième solution est de simplifier la sortie de la modèle : Au debut, on souhaite d'obtenir une séquence des point de vitesse pas-à-pas pour tracer une trajectoire. Mais il a provoqué une erreur de vitesse mauvaise. Donc, on peut-être relie un fil entre la point de départ et la destination. On maintient une vitesse fixe, et chaque fois on just contrôle un peu de l'angle du robot pour naviguer jusqu'à la destination.

Finalement, nous avons décider de changer la méthode pour connecter entre les deux réseaux. Nous n'utilisons pas de 'reshape' mais nous n'utilisons qu'une liste pour connecter les données des images et les points de départ et les points de destination. Si ça marche pas bien, nous allons effectuer les autres méthodes.

Nous avons modifié la partie de connexion. Ici, c'est un message qui indique que le nombre de données pour représenter la carte est 300, le nombre de données pour chaque (X,Y,A) phase est 100. Donc le nombre de données dan un tableau combiné est 600.

Mais même si nous avons simplifié la méthode pour connecter les deux réseau, nous n'avons pas pouvoir résoudre notre problème.

Semaine 12-13 (Vacances)

Pendant le processus de la modification de nos programmes, nous avons trouvé beaucoup de problème dans nos réseaux. Donc, nous avons reprogrammer les deux parties: nous avons modifier le réseau de 'CNN' en traitant le niveau de gris. Et nous avons utilisé un réseau 'DQN' (Deep Q-Network) pour remplacer le réseau 'LSTM'. Après avoir fait des efforts, nous avons réaliser à prédire la trajectoire correcte sur les cartes quelconques.

Les programmes partiels:

• Initialisation:

 # crée une modèle de DQN
   model_name = 'dqn_model_demo.h5'
   
 # quand le robot arrive à (row,col)，on met la valeur de matrice dans la position (row,col) égale POS_VALUE
   TMP_VALUE = 2
 # point de départ
   start_state_pos = sta_P
 # destination
   target_state_pos = tar_P
 
 # les actions du robot 
   actions = dict(
      up = 0,
      down = 1,
      left = 2,
      right = 3
    )
 # dimension des actions，est aussi la dimension des sorties du réseau
   action_dimention = len(actions)
 
 # les récompenses: si ‘arriver à la destination’, rewards=1; si 'marcher dans des zones sans obstacles', rewards=-0.01; si ‘hors des limites ou collision’, rewards=-1
   reward_dict = {'reward_0': -1, 'reward_1': -0.01, 'reward_2': 1}

• Définition:

 class DQNAgent:
   def __init__(self,agent_model=None):
       self.memory = deque(maxlen=100)
       self.alpha = 0.01
       self.gamma = 0.9  # decay rate
       # exploration des actions
       self.epsilon = 1
       # valeur minimale
       self.epsilon_min = 0.2
       # taux d'atténuation
       self.epsilon_decay = 0.995
       self.learning_rate = 0.001
       if agent_model is None:
           self.model = self.dqn_model()
       else:
           self.model = agent_model
 
   # modèle de DQN
   def dqn_model(self):
       inputs = Input(shape=(maze.shape[0], maze.shape[1],1))
       layer1 = Conv2D(filters=32,kernel_size=(3,3),strides=(1,1),padding='same')(inputs)
       layer2 = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same')(layer1)
       layer3 = Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same')(layer2)
       layer4 = Flatten()(layer3)
       predictions = Dense(action_dimention, activation='softmax')(layer4)
       model = Model(inputs=inputs, outputs=predictions)
       model.compile(optimizer='sgd',
                     loss=mean_squared_error,
                     )
       return model

Vérifier la correction:

On envoie une carte, un point de départ et une destination quelconques comme les entrées aux nos réseaux. Après nos réseaux avoir calculé, nous pouvons obtenir une trajectoire prévue. La première image est la carte qu'on a choisit comme l'entrée. La deuxième image est la trajectoire optimale que le simulateur a donnée. La troisième image est la trajectoire que nos réseaux ont prédite. Nous pouvons trouver que la trajectoire prévue est correcte, elle peut bien éviter les obstacles et arriver à la destination. Même si elle est un peu différente que la trajectoire donnée par le simulateur.

Puis, le programme peut enregistrer une séquence de points de vitesse prévue dans une document nommé 'DQN_result':

En plus on obtient aussi un diagramme vitesse prévue par temps :

Rouge: Vitesse de X; Bleu: Vitesse de Y; Jaune: Viesse de l'angle.