Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision
Révision précédente
l_intelligence_du_semaphore [2019/08/18 11:45]
serge [Reconnaître plusieurs sémaphores]
l_intelligence_du_semaphore [2019/10/10 15:27] (Version actuelle)
serge Tag0 Added: python
Ligne 8: Ligne 8:
 {{ chappe.jpeg?​400 }} {{ chappe.jpeg?​400 }}
 </​WRAP>​ </​WRAP>​
 +
 +<WRAP center round box 60% centeralign>​
 +**Calcul de [[Le sémaphore avec TensorFlow|Le sémaphore avec TensorFlow]] sur GPU au lieu du CPU avec TensorFlow**
 +</​WRAP>​
 +=====Les sources sur GitHub=====
 +  * **[[https://​github.com/​sergeLabo/​semaphore|semaphore chez github.com]]**
 =====Les images utilisées pour l'​apprentissage===== =====Les images utilisées pour l'​apprentissage=====
 ====Images sorties de Blender==== ====Images sorties de Blender====
Ligne 297: Ligne 303:
 </​file> ​   ​ </​file> ​   ​
  
-=====La reconnaissance seule===== 
-L'​image en entrée doit être: 
-  * 40 x 40 pixels 
-  * en noir et blanc convertit en 0 et 1, que des 0 et des 1 dans le array 
-  * Floutée entre 5 et 7 
-  * Convertie en vecteur ligne: img = img.reshape(1600) 
- 
-====Les poids==== 
-Le fichier weights.npy doit être dans le dossier du script. 
-**[[https://​github.com/​sergeLabo/​semaphore/​raw/​master/​weights.npy|weights.npy téléchargeable sur GitHub]]**. 
- 
-====La class Reconnaissance==== 
-<code python> 
-import numpy as np 
-import cv2 
- 
- 
-def sigmoid(x): 
-    return 1 / (1 + np.exp(-x)) 
-def relu(x): 
-    return np.maximum(0,​ x) 
- 
-class Reconnaissance:​ 
-    def __init__(self):​ 
-        self.weight = np.load('​weights.npy'​) 
- 
-    def testing(self,​ img): 
-        vecteur_ligne = img 
-        layers = [1600, 100, 100, 27] 
-        activations = [relu, relu, sigmoid] 
-        for k in range(len(layers)-1):​ 
-            vecteur_ligne = activations[k](np.dot(self.weight[k],​ 
-                                                       ​vecteur_ligne)) 
-            reconnu = np.argmax(vecteur_ligne) 
-        return reconnu 
-</​code>​ 
- 
-====Adaptation de l'​image==== 
-<code python> 
-# frame peut être la capture d'une webcam 
-cv2.imshow('​RGB Input',​ frame) 
- 
-# Application d'un seuil pour extraire le sémaphore du fond 
-# Le seuil est à adapter en fonction de la couleur du sémaphore 
-hsv = cv2.cvtColor(frame,​ cv2.COLOR_BGR2HSV) 
-lower = np.array([120,​ 80, 80]) 
-upper = np.array([255,​ 255, 255]) 
-img = cv2.inRange(hsv,​ lower, upper) 
- 
-# Flou: GaussianBlur semble mieux que Averaging=cv2.blur() 
-img = cv2.GaussianBlur(img,​ (5, 5), 0) 
- 
-# Resize 
-img = cv2.resize(img,​ (40, 40), interpolation=cv2.INTER_AREA) 
- 
-# Noir et blanc, sans gris 
-ret, nb = cv2.threshold(img,​ 2, 255, cv2.THRESH_BINARY) 
- 
-# Valeur 0 ou 1 
-nb = nb / 255 
-                ​ 
-# Reshape pour avoir un vecteur ligne 
-vect = nb.reshape(40*40) 
- 
-reco = Reconnaissance() 
-reconnu = reco.testing(vect) 
-print("​Caractère reconnu:",​ reconnu) 
-</​code>​ 
- 
-====Les fichiers pour un test avec Webcam et un sémaphore en carton==== 
-  * **[[https://​github.com/​sergeLabo/​semaphore/​tree/​master/​reconnaissance|Reconnaissance sur GitHub]]** 
  
 ===== Etape suivante: YOLO Darknet===== ===== Etape suivante: YOLO Darknet=====
 **[[computer_vision_and_pattern_recognition_segmentation_d_image|Computer Vision and Pattern Recognition Mask R-CNN]]** **[[computer_vision_and_pattern_recognition_segmentation_d_image|Computer Vision and Pattern Recognition Mask R-CNN]]**
  
-===== Idées de choses à faire par Max===== +{{tag> ​bge ia python ​sb semaphore ​}}
- +
-  * Essayer d'​implémenter un petit réseau de neurones convolutif pas trop compliqué. +
-  * Essayer de reconnaître les coordonnées de la position du sémaphore (un quadrilatère entourant le sémaphore sur l'​image) en plus de sa valeur. +
-  * Essayer de reconnaître la forme du sémaphore plutôt que l'​associé à un symbole : Reconnaître la position du régulateur et des 2 indicateurs. Les buts étant de pouvoir changer l'​alphabet sans réapprendre,​ et de pouvoir dessiner un sémaphore schématique tel que reconnu par l'​IA. +
-  * Essayer de reconnaître plusieurs sémaphores simultanément. Le but est de pouvoir choisir lequel on veut pouvoir imiter. +
- +
-==== Idée directrice ==== +
-Réaliser 2 apprentissages indépendants pour faciliter l'​apprentissage et ajouter du filtrage intermédiaire. Je propose de réaliser un premier apprentissage qui reconnaîtrait la position d'un sémaphore dans une image. Il retournerait ses coordonnées. Le second apprentissage reconnaîtrait la forme d'un sémaphore dans un cadre particulier. +
-\\ \\ +
-Je vois plusieurs avantages : +
-  * Nous savons que dans une vidéo, un sémaphore ne peut pas se promener d'un bout à l'​autre d'une frame de manière discontinue. On peut donc facilement filtrer les faux positifs de détection d'un sémaphore du premier apprentissage qui se déplaceraient de manière discontinue. +
-  * Une fois la première reconnaissance réalisé il est facile de recadrer l'​image en entrée et la présenter dans un format particulier au second apprentissage (ex: 40px x 40px). +
-  * Il est plus facile d'​apprendre à détecter plusieurs positions de sémaphore simultanés que de reconnaitre la forme de plusieurs sémaphore simultanément. +
-  * Si nous reconnaissons plusieurs sémaphores simultanément,​ nous pourrons lancer un traitement de reconnaissance de leur forme pour chaque détection indépendament. +
-  * Un filtrage intelligent pourrait comprendre qu'un sémaphore est occulté par un obstacle mouvant avant d'etre de nouveau visible. +
-==== Petit réseau convolutif ==== +
-  * En entré, il faudrait une première couche identique, et une deuxième couche qui n'est pas relié à tous les neurones de la première couche, mais uniquement à un ensemble représentant une tuile. Il faut donc modifier l'algo actuel qui relie toujours tous les neurones de la couche N-1 à tous les neurones de la couche N. +
-  * Comment paver l'​image de tuiles ? Est ce que les tuiles doivent se chevaucher ? Il serait interessant de variabiliser la taille des tuiles et leur chevauchement. +
- +
-==== Reconnaître les coordonnées du sémaphore ==== +
-  * Il faut lors de la génération des images ajouter une méta information dans l'​image indiquant dans les coordonnées d'un quadrilataire inscrivant le sémaphore. +
-  * Quels types de coordonnées ? Les coordonées de 2 angles opposés ? les coordonées d'un angle et 2 distances ? autre ? +
-  * Comment modifier la sortie du réseau de neurones pour reconnaître le couple (position du sémaphore, valeur) ? +
- +
-==== Reconnaître la forme du sémaphore ==== +
-  * Plutôt que de tagger l'​image avec un symbole, il faudrait la tagger avec la forme du sémaphore. +
-  * Quels informations pour coder la forme ? Les 3 Angles absolue du régulateur et des indicateurs ? +
-  * Comment modifier la sortie du réseau de neurones pour reconnaître le couple (position du sémaphore, forme du sémaphore) ? +
- +
-==== Reconnaître plusieurs sémaphores ==== +
-  * Comment modifier la sortie du réseau de neurones pour reconnaître plusieurs couples (position, forme) ? +
- +
-{{tag>​ia ​semaphore ​sb realisations_logicielles bge}}+
  
  • l_intelligence_du_semaphore.1566121557.txt.gz
  • Dernière modification: 2019/08/18 11:45
  • par serge