Classification EV3 x Pyrhon Machine Learning Partie 3

Le contenu de cet article est en version bêta et est susceptible de changer. Dans cet article, nous utiliserons la version éducative LEGO® MINDSTORMS EV3 (ci-après EV3) et l'environnement Python pour identifier les couleurs à l'aide de la classification. J'irai. Pour la construction de l'environnement, veuillez vous référer à l'article sur la construction de l'environnement. De plus, dans l'article précédent, le contenu était une combinaison de traçage de ligne et de régression linéaire.

Apprentissage automatique avec EV3 Partie 1 Construction de l'environnement: ici Apprentissage automatique avec EV3 Partie 2 Régression linéaire: ici Apprentissage automatique avec classification EV3 Partie 3: cet article

référence

Le contenu de cet article est basé sur les livres suivants. Le contrôle de base d'EV3 à l'aide de Python est couvert ci-dessous.

Introduction à l'IA à partir d'un robot

Environnement dans cet article

PC Windows10 Python 3.7.3 Environnement de développement VisualStudioCode
EV3 ev3dev

table des matières

Méthode de classification
Que faire
Modèle EV3 et lecture de la couleur
Créer un programme
Exécutez le programme
Résultat de l'exécution
Résumé

Méthode de classification

SVM (machine à vecteurs de soutien)

Une technique pour dessiner des limites pour séparer les données lorsqu'elles sont dispersées

Tracez une ligne de démarcation = prédire la classification, mais utilisez les données antérieures pour la prédiction. À ce moment-là, si des données supplémentaires telles que des valeurs aberrantes sont utilisées, la précision peut diminuer. Par conséquent, SVM n'utilise que certaines données vraiment nécessaires pour la prédiction. Les données requises pour la prédiction sont appelées un vecteur de support, et une méthode d'apprentissage automatique utilisant le vecteur de support est une machine à vecteur de support.

Choses à faire

Cette fois, le capteur de couleur collecte les numéros RVB (degré de rouge, vert et bleu) et les numéros d'étiquette de plusieurs couleurs en tant qu'ensemble. Le capteur de couleur EV3 peut acquérir des valeurs RVB de 0 à 255. Sur la base du groupe de données collectées, la limite de la couleur des données est définie et l'inférence est effectuée sur la base des données.

Voici un exemple des données collectées cette fois

Modèle EV3 et couleur de lecture

Lisez la couleur à la fin du cours que vous avez utilisé la dernière fois. Puisqu'il est possible d'utiliser certaines couleurs comme données d'apprentissage en modifiant la définition des étiquettes dans le programme, il est possible de classer les couleurs préférées. 　　　　　　

Cette fois également, nous utiliserons le même modèle EV3 "Base Robo" que la dernière fois. Comme nous ne déplaçons pas le moteur cette fois, il n'y a pas de problème si nous avons un bloc intelligent et un capteur de couleur, mais comme le capteur de couleur doit avoir un espace d'environ 0,5 cm à 1 cm de la surface de lecture, le capteur de couleur peut être fixé de manière stable. Utilisez le modèle. 　　　　　

Créer un programme

Cette fois, créez les deux programmes suivants.

Programme latéral EV3 data_get_color.py
Programme côté PC Classification.py

Comme dans le temps précédent, le traitement des données et l'inférence proprement dite sont effectués par le programme côté PC, et les valeurs RVB couleur sont acquises et transmises du côté EV3. La relation entre chaque programme est illustrée dans la figure ci-dessous.

Programme annexe EV3

Le programme secondaire EV3 data_get_color.py est créé dans l'espace de travail sur VSCode. Veuillez vous reporter aux articles suivants pour savoir comment créer un espace de travail et le transférer vers EV3. EV3 x Pyrhon Machine Learning Partie 1 Construction de l'environnement

import time
import socket
import sys
from ev3dev2.button import Button
from ev3dev2.sensor import INPUT_3
from ev3dev2.sensor.lego import ColorSensor


def dataget(color_dic, color_num):
    _rgb_data = color.raw
    _rgb_data = list(_rgb_data)
    _rgb_data.append(color_num)
    _rgb_data_str = ','.join(map(str, _rgb_data))
    s.send(_rgb_data_str.encode())
    print('\n'+'rgb_color = {}'.format(_rgb_data_str))


def predict():
    _rgb_data = color.raw
    _rgb_data = list(_rgb_data)
    _rgb_data_str = ','.join(map(str, _rgb_data))
    s.send(_rgb_data_str.encode())
    pre_color = s.recv(1024).decode()
    print('\n'+'predict_color = {}'.format(color_dic[int(pre_color[0])]))


 sensors&motors definition
button = Button()
color = ColorSensor(INPUT_3)

 gyro initialize
color.mode = 'RGB-RAW'

 variable initialize
color_dic = {
            1: 'RED',
            2: 'GREEN',
            3: 'BLUE'
            }

color_num = 1
color_max = len(color_dic)

 get gyrodate and into array
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect(('169.254.85.105', 50010))    # your PC's Bluetooth IP & PORTpy
    for cnt in range(color_max):
        s.send((color_dic[cnt+1]).encode())
        time.sleep(0.1)
    s.send(('END').encode())
    print('Start program...')
    while not(button.backspace):
        if button.up:
            color_num += 1
            time.sleep(0.1)
            if color_num > color_max:
                color_num = color_max
        elif button.down:
            color_num -= 1
            time.sleep(0.1)
            if color_num < 1:
                color_num = 1
        elif button.right:
            msg = 'save'
            s.send(msg.encode())
            dataget(color_dic, color_num)
        elif button.left:
            msg = 'predict'
            s.send(msg.encode())
            predict()
        print('\r'+'save_color = {}   '.format(color_dic[color_num]), end='')
        time.sleep(0.1)

print('\n'+'End program')
sys.exit()

Veuillez noter que si vous commentez l'environnement EV3 en japonais, une erreur se produira en raison de la nature du code de caractère.

Le s.connect (('169.254.207.161', 50010)) décrit dans la seconde moitié est réécrit en fonction de l'environnement comme précédemment.

Vous pouvez changer le nom de l'étiquette lors de l'enregistrement en tant que données en changeant les parties ROUGE, VERTE, BLEUE suivantes. Cette fois, nous lirons le rouge, le vert et le bleu, alors laissez-les comme suit.

 variable initialize
color_dic = {
            1: 'RED',
            2: 'GREEN',
            3: 'BLUE'
            }

Programme côté PC

Dans le programme côté PC, la valeur de couleur et l'étiquette envoyées depuis EV3 sont enregistrées dans un fichier CSV en tant qu'ensemble, et lorsqu'un message d'inférence est envoyé du côté EV3, quelle couleur est actuellement affichée en fonction du groupe de données? Ou déduire et afficher le résultat.

Créez Classification.py comme document texte dans le dossier programme comme auparavant et décrivez le contenu suivant.

import socket
import sys
import csv
import numpy as np
import pandas as pd
import os.path
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier
from sklearn.ensemble import RandomForestClassifier as RFC
from sklearn.metrics import accuracy_score


 setting svm
C = 1.
kernel = 'rbf'
gamma = 0.01
estimator = SVC(C=C, kernel=kernel, gamma=gamma)
clf = OneVsRestClassifier(estimator)

x_data = np.zeros(0)
y_data = np.zeros(0)

color_elements = None

color_dic = {}
color_cnt = 1

# Créer un fichier de données
if os.path.exists('color_data.csv') == False:
    writedata = ['red', 'green', 'blue', 'color']
 f = open ('color_data.csv', 'w', newline = '') # Ouvrir le fichier
    writer = csv.writer(f)
 writer.writerow (writedata) # Ecrire des données
    f.close()
 data = pd.read_csv ("color_data.csv", sep = ",") # lire le fichier csv

# Divisez les données lues en données d'entrée et en étiquettes
x_data = data.loc[:, ["red", "green", "blue"]]
y_data = data.loc[:, "color"]

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind(('169.254.85.105', 50010))  # your PC's Bluetooth IP & PORT
    s.listen(1)
    print('Start program...')
    while True:
        conn, addr = s.accept()
        with conn:
 #Créez le même dictionnaire de couleurs créé par le programme côté EV3
            while True:
                color_elements = conn.recv(1024).decode()
                if color_elements == 'END':
                    break
                color_dic[color_cnt] = color_elements
                color_cnt += 1
            print('color_dic = {}'.format(color_dic))

 #Change de comportement en fonction du message
            while True:
                rgb_data = conn.recv(1024).decode()
                if not rgb_data:
                    break
 # Envoyer la valeur à EV3 après déduction en utilisant les données accumulées
                elif rgb_data == 'predict':
                    train_x, test_x, train_y, test_y = train_test_split(x_data,
                                                                        y_data)
                    clf.fit(train_x, train_y)
                    y_pred = clf.predict(test_x)
                    rgb_data = conn.recv(1024).decode()
                    rgb_data = rgb_data.split(',')
                    pre_color = clf.predict([rgb_data])
                    print('predict_color = {}'.format(color_dic[pre_color[0]]))
                    conn.send(str(pre_color[0]).encode())
 Sauvegardez les données envoyées depuis # EV3
                elif rgb_data == 'save':
                    rgb_data = conn.recv(1024).decode()
                    rgb_data = rgb_data.split(',')
                    print('rgb_data = {}'.format(rgb_data))
                    np.append(y_data, rgb_data[0:2])
                    np.append(y_data, int(rgb_data[3]))
                    writedata = rgb_data
                    f = open('color_data.csv', 'a', newline='')
                    writer = csv.writer(f)
                    writer.writerow(writedata)
                    f.close()
            print('End program')
            sys.exit()

Le s.bind (('169.254.207.161', 50010)) décrit dans la seconde moitié est changé en fonction de l'environnement comme le programme annexe EV3. Comment vérifier et modifier l'environnement [Article précédent](https://qiita.com/Hiroki-Fujimoto/items/6dae8c407e56a38625cf#%E3%83%97%E3%83%AD%E3%82%B0%E3% 83% A9% E3% 83% A0% E3% 81% AE% E4% BD% 9C% E6% 88% 90) Ou vérifiez ce qui suit. [Paramètres IP pour la communication par socket](https://qiita.com/Hiroki-Fujimoto/items/6dae8c407e56a38625cf#%E3%82%BD%E3%82%B1%E3%83%83%E3%83%88%E9 % 80% 9A% E4% BF% A1% E3% 81% AEip% E8% A8% AD% E5% AE% 9A)

Exécution du programme

Une fois que vous avez créé deux programmes, exécutez chacun d'eux.

Exécutez cd Desktop \ program à partir de l'invite de commande (\ est synonyme de \ mark)
Ensuite, exécutez python Classification.py à l'invite de commande.

Après l'exécution, Démarrer le programme ... sera affiché et le système sera en état de veille.

Ouvrez le terminal SSH de l'EV3 connecté sur VS Code et exécutez cd ev3 workspace /
Exécutez python3 data_get_gyro.py dans le terminal SSH
Installez EV3 sur la couleur attachée au cours, acquérez la valeur RVB avec le capteur de couleur et envoyez-la au PC. Puisque l'opération est définie pour chaque bouton d'EV3, appuyez sur le bouton en fonction de l'opération et collectez les données.

--Haut: Changer la couleur (étiquette) pour enregistrer --Bas: changer la couleur (étiquette) à enregistrer --Droite: Lorsque vous appuyez sur le bouton, la valeur et l'étiquette du capteur de couleur à ce moment-là sont envoyées au PC (collecte de données). --Gauche: Lorsque le bouton est enfoncé, la valeur du capteur de couleur à ce moment-là est envoyée au PC (inférence)

Puisque l'opération est définie comme décrit ci-dessus, alignez l'étiquette avec la couleur que vous souhaitez collecter avec les boutons haut et bas, et appuyez sur le bouton droit pour collecter les données. Appuyez sur les boutons haut et bas pour changer le nom de l'étiquette à collecter sur VS Code.

Lorsque les données de couleur sont collectées avec le bouton droit, les valeurs RVB et les étiquettes sont sorties sur VSCode et sur l'invite de commande comme indiqué ci-dessous, et enregistrées dans un fichier CSV.

De même, collectez des données pour chaque étiquette.

Résultat d'exécution

Après avoir collecté des données dans une certaine mesure, appuyez une fois sur le bouton en haut à gauche d'EV3 pour terminer le programme.

Confirmez que CSV a été créé.

Exécutez à nouveau les programmes côté PC et côté EV3 dans la même procédure, Appuyez sur le bouton gauche de chaque couleur collectée et vérifiez le résultat de l'inférence côté PC. 　　　　

Il peut être confirmé que chaque couleur peut être distinguée.

Sommaire

Nous avons pu classer en fonction des données réellement reçues du robot. Cette fois, nous avons utilisé la méthode SVM, mais il est également possible d'implémenter l'apprentissage automatique avec d'autres méthodes de classification telles que la forêt aléatoire en modifiant la description de la spécification du modèle de Scikit-learn. Dans l'apprentissage automatique récent, il y a beaucoup de choses qui sont simplifiées dans le PC, mais cela semble familier en termes de pouvoir vérifier les résultats d'exécution sur le bord (côté robot) et d'utiliser les données collectées par vous-même comme cette fois. Je me demande si cela peut être fait.