[PYTHON] EV3 x Pyrhon Maschinelles Lernen Teil 3 Klassifizierung

Der Inhalt dieses Artikels befindet sich in der Beta-Phase und kann sich ändern. In diesem Artikel verwenden wir die Lernversion LEGO® MINDSTORMS EV3 (im Folgenden EV3) und die Python-Umgebung, um Farben mithilfe der Klassifizierung zu identifizieren. Ich werde gehen. Informationen zum Umweltbau finden Sie im Artikel zum Umweltbau. Im vorherigen Artikel war der Inhalt eine Kombination aus Linienverfolgung und linearer Regression.

Maschinelles Lernen mit EV3 Teil 1 Umgebungskonstruktion: hier Maschinelles Lernen mit EV3 Teil 2 Lineare Regression: hier Maschinelles Lernen mit EV3 Teil 3 Klassifizierung: Dieser Artikel

Referenz

Der Inhalt dieses Artikels basiert auf den folgenden Büchern. Die grundlegende Steuerung von EV3 mit Python wird unten behandelt.

Einführung in die KI beginnend mit einem Roboter

Umgebung in diesem Artikel

PC Windows10 Python 3.7.3 Entwicklungsumgebung VisualStudioCode
EV3 ev3dev

Inhaltsverzeichnis

Klassifizierungsmethode
Was ist zu tun?
EV3-Modell und Lesefarbe
Programm erstellen
Führen Sie das Programm aus
Ausführungsergebnis
Zusammenfassung

Klassifizierungsmethode

SVM (Support Vector Machine)

Eine Technik zum Zeichnen von Grenzen, um Daten zu trennen, wenn sie verstreut sind.

Zeichnen Sie eine Grenzlinie = sagen Sie die Klassifizierung voraus, verwenden Sie jedoch frühere Daten für die Vorhersage. Wenn zu diesem Zeitpunkt zusätzliche Daten wie Ausreißer verwendet werden, kann sich die Genauigkeit verringern. Daher verwendet SVM nur einige Daten, die für die Vorhersage wirklich notwendig sind. Die für die Vorhersage erforderlichen Daten werden als Unterstützungsvektor bezeichnet, und ein maschinelles Lernverfahren unter Verwendung des Unterstützungsvektors ist eine Unterstützungsvektormaschine.

Dinge die zu tun sind

Diesmal sammelt der Farbsensor RGB (Grad von Rot, Grün und Blau) und Etikettennummern mehrerer Farben als Satz. Der EV3-Farbsensor kann RGB-Werte von 0 bis 255 erfassen. Basierend auf der gesammelten Datengruppe wird die Grenze der Farbe der Daten definiert und anhand der Daten eine Inferenz durchgeführt.

Das Folgende ist ein Beispiel für die diesmal gesammelten Daten

EV3 Modell und Lesefarbe

Lesen Sie die Farbe am Ende des Kurses, den Sie zuletzt verwendet haben. Da es möglich ist, einige Farben als Trainingsdaten zu verwenden, indem die Definition der Beschriftungen im Programm geändert wird, ist es möglich, Lieblingsfarben zu klassifizieren. 　　　　　　

Auch dieses Mal werden wir das gleiche EV3-Modell "Base Robo" wie beim letzten Mal verwenden. Da wir den Motor diesmal nicht bewegen, gibt es kein Problem, wenn es einen intelligenten Block und einen Farbsensor gibt. Da der Farbsensor jedoch einen Abstand von etwa 0,5 cm bis 1 cm von der Lesefläche haben muss, kann der Farbsensor stabil befestigt werden Verwenden Sie das Modell. 　　　　　

Programm erstellen

Erstellen Sie dieses Mal die folgenden zwei Programme.

EV3-Nebenprogramm data_get_color.py
PC-seitiges Programm Classification.py

Wie in der vorherigen Zeit werden die Datenverarbeitung und die Inferenz selbst vom PC-seitigen Programm ausgeführt, und Farb-RGB-Werte werden auf der EV3-Seite erfasst und übertragen. Die Beziehung zwischen den einzelnen Programmen ist in der folgenden Abbildung dargestellt.

EV3-Nebenprogramm

Das EV3-Seitenprogramm "data_get_color.py" wird im Arbeitsbereich von VSCode erstellt. In den folgenden Artikeln erfahren Sie, wie Sie einen Arbeitsbereich erstellen und auf EV3 übertragen. EV3 x Pyrhon Maschinelles Lernen Teil 1 Umgebungskonstruktion

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()

Bitte beachten Sie, dass beim Kommentieren der EV3-Umgebung auf Japanisch aufgrund der Art des Zeichencodes ein Fehler auftritt.

Der in der zweiten Hälfte beschriebene s.connect (('169.254.207.161', 50010)) wird wie zuvor entsprechend der Umgebung umgeschrieben.

Sie können den Beschriftungsnamen bei der Aufzeichnung als Daten ändern, indem Sie die folgenden ROTEN, GRÜNEN, BLAUEN Teile ändern. Dieses Mal werden wir rot, grün und blau lesen, also lassen Sie sie wie folgt.

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

PC-seitiges Programm

Im PC-seitigen Programm werden der von EV3 gesendete Farbwert und das Etikett als Satz in einer CSV-Datei aufgezeichnet. Wenn eine Inferenznachricht von der EV3-Seite gesendet wird, welche Farbe wird derzeit basierend auf der Datengruppe angezeigt? Oder schließen Sie das Ergebnis ab und zeigen Sie es an.

Erstellen Sie Classification.py wie zuvor als Textdokument im Ordner program und beschreiben Sie den folgenden Inhalt.

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

# Erstellen einer Datendatei
if os.path.exists('color_data.csv') == False:
    writedata = ['red', 'green', 'blue', 'color']
 f = open ('color_data.csv', 'w', newline = '') # Datei öffnen
    writer = csv.writer(f)
 writer.writerow (writedata) # Daten schreiben
    f.close()
 data = pd.read_csv ("color_data.csv", sep = ",") # CSV-Datei lesen

# Teilen Sie die gelesenen Daten in Eingabedaten und Beschriftungen
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:
 #Erstellen Sie dasselbe Farbwörterbuch, das vom Programm auf der EV3-Seite erstellt wurde
            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))

 # Verhalten je nach Nachricht ändern
            while True:
                rgb_data = conn.recv(1024).decode()
                if not rgb_data:
                    break
 # Senden Sie den Wert nach der Inferenz mit den gesammelten Daten an EV3
                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())
 Speichern Sie die von # EV3 gesendeten Daten
                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()

Das in der zweiten Hälfte beschriebene "s.bind (('169.254.207.161', 50010))" wird je nach Umgebung wie das EV3-Nebenprogramm geändert. So überprüfen und ändern Sie die Umgebung [Vorheriger Artikel](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) Oder überprüfen Sie Folgendes. [IP-Einstellungen für die Socket-Kommunikation](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)

Programmausführung

Nachdem Sie zwei Programme erstellt haben, führen Sie jedes aus.

Führen Sie cd Desktop \ program an der Eingabeaufforderung aus (\ ist gleichbedeutend mit \ mark)
Führen Sie als Nächstes an der Eingabeaufforderung python Classification.py aus.

Nach der Ausführung wird Startprogramm ... angezeigt und das System befindet sich im Standby-Zustand.

Öffnen Sie das SSH-Terminal des mit VS Code verbundenen EV3 und führen Sie cd ev3 workspace / aus
Führen Sie "python3 data_get_gyro.py" im SSH-Terminal aus
Installieren Sie EV3 auf der Farbe, die dem Kurs zugeordnet ist, erfassen Sie den RGB-Wert mit dem Farbsensor und senden Sie ihn an den PC. Da die Operation für jede Taste von EV3 eingestellt ist, drücken Sie die Taste entsprechend der Operation und sammeln Sie die Daten.

--Top: Wechseln Sie die Farbe (Beschriftung) zum Speichern --Bottom: Wechseln Sie die Farbe (Beschriftung) zum Speichern --Rechts: Wenn die Taste gedrückt wird, werden der Wert und die Beschriftung des Farbsensors zu diesem Zeitpunkt an den PC gesendet (Datenerfassung).

Links: Wenn die Taste gedrückt wird, wird der Wert des Farbsensors zu diesem Zeitpunkt an den PC gesendet (Inferenz).

Da der Vorgang wie oben beschrieben eingestellt ist, richten Sie das Etikett mit den Auf- und Ab-Tasten an der Farbe aus, die Sie erfassen möchten, und drücken Sie die rechte Taste, um die Daten zu erfassen. Drücken Sie die Auf- und Ab-Tasten, um den Namen des Etiketts zu ändern, das im VS-Code erfasst werden soll.

Wenn Farbdaten mit der rechten Taste erfasst werden, werden RGB-Werte und Beschriftungen wie unten gezeigt in VSCode und an der Eingabeaufforderung ausgegeben und in einer CSV-Datei gespeichert.

Sammeln Sie auf ähnliche Weise einige Daten für jedes Etikett.

Ausführungsergebnis

Drücken Sie nach dem Sammeln von Daten die Taste oben links auf EV3, um das Programm einmal zu beenden.

Bestätigen Sie, dass CSV erstellt wurde.

Führen Sie die Programme auf der PC-Seite und der EV3-Seite erneut auf die gleiche Weise aus. Drücken Sie die linke Taste für jede gesammelte Farbe und überprüfen Sie das Inferenzergebnis auf der PC-Seite. 　　　　

Es kann bestätigt werden, dass jede Farbe unterschieden werden kann.

Zusammenfassung

Wir konnten anhand der tatsächlich vom Roboter empfangenen Daten klassifizieren. Dieses Mal haben wir die SVM-Methode verwendet, aber es ist auch möglich, maschinelles Lernen mit anderen Klassifizierungsmethoden wie Random Forest zu implementieren, indem die Beschreibung der Modellspezifikation von Scikit-learn geändert wird. Beim jüngsten maschinellen Lernen gibt es viele Dinge, die im PC vereinfacht werden, aber es ist bekannt, die Ausführungsergebnisse am Rand (Roboterseite) überprüfen zu können und die von Ihnen wie diesmal gesammelten Daten zu verwenden. Ich frage mich, ob es möglich ist.