Entdecken Sie unsere Lehrmaterialien

Spielerische Aktivität für eine Klasse mit mehreren Robotern: Die Schülerinnen und Schüler trainieren die Roboter, auf einer Rennstrecke zu fahren, und anschließend wird ein Rennen veranstaltet. Die Schülerinnen und Schüler lernen durch Manipulation das Prinzip des überwachten Lernens und die Bedeutung der Qualität der Trainingsdaten kennen.

[Videoinhalt folgt]

‍

‍

Einführung

Machine Learning ist ein Zweig der künstlichen Intelligenz, der darauf abzielt, Computern die Möglichkeit zu geben, zu lernen. Ein Computer ist nicht intelligent, er führt lediglich Aufgaben aus. Ihm wird in Form von Programmen beschrieben, was er tun soll und wie er es tun soll. Das nennt man Programmierung.

Machine Learning befasst sich mit komplexen Themen, bei denen die herkömmliche Programmierung an ihre Grenzen stößt. Ein Programm zu bauen, das ein Auto fährt, wäre sehr komplex oder sogar unmöglich. Das liegt an den sehr vielen möglichen Fällen, die es zu behandeln gilt... Machine Learning geht dieses Problem anders an. Anstatt zu beschreiben, was zu tun ist, lernt das Programm durch das "Beobachten" von Experimenten selbst, wie es fahren soll.

Machine Learning: Einem Programm die Möglichkeit geben, Aufgaben zu erlernen, die nicht programmiert wurden.

Anhand der Versuchsdaten, die der Lernalgorithmus als Eingabe nimmt, wird er selbstständig eine Funktionshypothese ableiten. Diese wird er für neue Fälle verwenden und seine Erfahrungen im Laufe der Zeit verfeinern.

Es gibt drei Arten des Lernens beim Machine Learning:

• Beaufsichtigtes Lernen
• Lernen Unüberwachtes Lernen
• Verstärktes Lernen

Das überwachte Lernen ist der häufigste Typ. Dabei wird den Lernalgorithmen ein Satz von Lerndaten (Training Set) in Form von Paaren (X, Y) zur Verfügung gestellt, wobei X die Vorhersagevariablen (oder Eingabedaten) und Y das Ergebnis der Beobachtung (oder Entscheidung) ist. Basierend auf dem Training Set wird der Algorithmus eine mathematische Funktion finden, die (am besten) X nach Y transformiert. Mit anderen Worten, der Algorithmus wird eine Funktion F finden, so dass Y≈F(X) .

So weiß er in einer Situation X, welche Entscheidung Y treffen muss.

Lernsituation und Trainingsset des Roboters AlphAI

Nun müssen die Situationen X und die erwarteten Entscheidungen Y angegeben werden. 

Die vorgeschlagene Fallstudie ist die Bewegung des Roboters in einer roten Arena. Das Ziel ist, dass sich der Roboter selbstständig bewegt, ohne die Wände zu berühren.

Dazu kann der Roboter folgende Entscheidungen treffen:

• Nach links abbiegen 
• Geradeaus gehen 
• Nach rechts abbiegen 

Um eine Entscheidung zu treffen, braucht man notwendigerweise ein Feedback, um über Daten (data oder training set) zu verfügen.

Dies wird von den Sensoren gegeben. Die hier getroffene Wahl ist die Verwendung der Kamera. Aus dem Bildbereich der Kamera werden zwei Bereiche extrahiert, die als Superpixel bezeichnet werden (siehe gegenüberliegende Seite). Der Rotanteil jedes Superpixels nimmt zu, wenn sich der Roboter aufgrund des Kontrasts zwischen der weißen Bahn und den roten Wänden den Wänden nähert.

‍

‍

Aktivität 1. Geben Sie in der folgenden Tabelle das Ergebnis an, das als Entscheidung erwartet wird, je nachdem, was in den Superpixeln gesichtet wird.

‍

Die oben genannten, vereinfachten Fälle, kommen nur sehr selten vor. Um in allen möglichen Fällen eine Entscheidung treffen zu können, muss man den numerischen Wert des Rotpegels erhalten. 

Das Bild aus der Kamera hat eine Größe von 48*64 Pixeln. Die Position und Geometrie der Superpixel ist in der folgenden Abbildung definiert:

‍

‍

Aktivität 2. Öffnen Sie die Datei get_values.py. Geben Sie den Pfad zum Bild forward_0.jpg an und führen Sie den folgenden Code aus, um das Bild in Python anzuzeigen.

from PIL import Image

import numpy as np

import matplotlib.pyplot as plt

def read_image(name):

    return np.array(Image.open(name, "r"))

img1=read_image("forward_0.jpg") #gibt den Pfad zum Bild an

plt.imshow(img1)

plt.show()

Sie sollen ein Bild der unten stehenden Form mit einer Größe von 48 Pixel mal 64 Pixel erhalten, das mit den drei RGB-Farben (Rot Grün Blau) codiert ist.

"img1" ist ein Pixelarray mit der Größe 48*64*3

In der Pixeltabelle findet man die drei Farbniveaus Rot Grün Blau, die zwischen 0 und 255 codiert sind.

Aus diesem Bild müssen wir die beiden zuvor definierten Superpixel extrahieren und eine Methode bestimmen, um den Rotwert für jedes Pixel zu erhalten.

‍

‍

Wir werden verschiedene Techniken vergleichen, um den besten Kontrast zwischen Rot und Weiß jedes Superpixels zu erreichen:

• die durchschnittliche Graustufe jedes Superpixels
• der durchschnittliche Rotwert jedes Superpixels
• den durchschnittlichen Grünwert jedes Superpixels

‍

In einem ersten Schritt wird das Bild mithilfe der Funktion rgb2gray wie folgt in Graustufen umgewandelt:

def rgb2gray(rgb):

    return np.dot(rgb[...,:3], [0.299, 0.587, 0.144]))

img2=rgb2gray(img1)

plt.imshow(img2, cmap="gray")

plt.show()

"img2" entspricht dem Graustufenbild. Es gibt also nur einen einzigen numerischen Wert zwischen 0 und 255 für jedes Pixel. 0 steht für ein weißes Pixel und 255 für ein schwarzes Pixel. Da die Superpixel im "unteren" Bereich des Bildes liegen

‍

‍

Aktivität 3. Schreiben Sie eine Funktion moyenne(img,x,y,height,width), die als Argumente ein Array von Pixeln "img" mit einem Farbpegel, die Koordinaten "x" und "y" des Pixels in der linken oberen Ecke eines Superpixels, die Höhe " height " und die Breite " width " eines Superpixels annimmt und den Durchschnitt des Farbpegels des Superpixels zurückgibt. 

‍

So ist es möglich, zwei Werte mit den beiden zuvor definierten Superpixeln mithilfe des Codes :

def get_two_values(img, x1=10, y1=28, x2=42, y2=28, height=16, width=13):

    value1 = moyenne(img, x1, y1, height, width)

    value2 = moyenne(img, x2, y2, height, width)

    return np.array((value1, value2))

Der Farbpegel des linken Superpixels wird als value1, der Farbpegel des rechten Superpixels als value2 bezeichnet. So ist es möglich, einen Punkt mit den Koordinaten (value1, value2) zu definieren

‍

‍

Aktivität 4. Führen Sie den Code aus, um die Werte value1 und value2 aus dem zuvor erhaltenen Graustufenbild abzurufen.

Die in der AlphAI-Software getroffene Wahl ist die Verwendung der Python-Funktion mean, die den Mittelwert der Tabelle berechnen wird.

‍

‍

‍

Aktivität 5. Wenden Sie die AlphAI-Software-Methode und die Methode mit Graustufen an und ergänzen Sie in beiden Fällen die Werte value1 und value2.

Funktion mean

Graue Ebene

Forward_0

Forwad_1

Left_0

Left_1

Right_0

Right_1

Right_2

Test_0

Test_1

‍

‍

Aktivität 6. Setzen Sie die Punkte auf dem Diagramm und identifizieren Sie die Bereiche, die den verschiedenen Entscheidungen entsprechen (links abbiegen, geradeaus fahren, rechts abbiegen). Ziehen Sie eine Schlussfolgerung darüber, welche Methode Sie für die Unterscheidung der verschiedenen Entscheidungen für am besten geeignet halten.

Superpixel-Intensität rechts

Intensität Superpixel links

‍

An diesem Punkt wäre es möglich, den Roboter anhand von bedingten Aktionen zu steuern, die sich auf diese Superpixelwerte beziehen. Im Folgenden wird der Ansatz anders sein. Wir werden eine Methode verwenden, die den Namen "Algorithmus der K nächsten Nachbarn" trägt.

‍

‍

Der Algorithmus der k nächsten Nachbarn, KNN

Wir werden uns einen sehr bekannten Algorithmus unter den Algorithmen des maschinellen Lernens genauer ansehen: den Algorithmus der K nächsten Nachbarn, oder KNN auf Englisch für " K Nearest Neighbours ". Dieser Algorithmus hat den Vorteil, dass er sehr einfach ist und daher eine gute Grundlage für das Verständnis des überwachten Lernens bietet.

Die Idee ist, eine große Anzahl von Daten zu verwenden, um der Maschine "beizubringen", wie sie eine bestimmte Art von Problemen lösen kann. Der Algorithmus ist besonders intuitiv, wenn die Daten als Punkte in einem zweidimensionalen Raum vorliegen, die somit auf dem Bildschirm angezeigt werden können. Wir werden daher eine Konfiguration mit nur 2 Sensoreingängen wählen, nämlich 2 "Superpixel" der Kamera, damit der Roboter die Wände erkennen und sich in der Arena ohne Blockaden bewegen kann. Danach kann er sich jedoch selbstständig fortbewegen, indem er aus den während der Trainingsphase eingegebenen Daten die Mehrheitsaktion der K nächsten Nachbarn auswählt.

Dieser überwachte Lernalgorithmus klassifiziert Daten auf der Grundlage ihrer Nähe zu bestehenden Trainingsdaten. Die neuen Daten betrachten k Nachbarn, die k nächsten, um zu entscheiden, welche Klassifizierung angewendet werden soll. Bei diskreten Daten, z. B. Punkten in einer Ebene oder im Raum, werden die nächsten Nachbarn mithilfe der euklidischen Distanz ausgewählt, aber auch andere Methoden können in anderen Situationen verwendet werden, z. B. die Manhattan-Distanz, wenn die Daten auf einem Raster oder einem Schachbrett angeordnet sind. Der Vorteil dieses Algorithmus liegt in der Wahl von k: Ist er zu klein, wird der Algorithmus zu anfällig für Fehler oder fehlende Daten, ist er zu groß, werden Daten berücksichtigt, die nicht berücksichtigt werden sollten.

Man kann die Funktionsweise von k-NN schematisieren, indem man sie in folgendem Pseudocode schreibt:

Anfang Algorithmus

Eingabedaten :

• einen Datensatz D, der dem erarbeiteten Trainingsset entspricht
• eine Funktion zur Berechnung des Abstands zwischen den beiden betrachteten Punkten mit den Koordinaten [x1,y1] und [x2,y2]. d=x2-x12+y2-y12
• eine ganze Zahl k, die die Anzahl der zu berücksichtigenden Nachbarn darstellt

Für eine neue Beobachtung X, deren Entscheidung Y vorhergesagt werden soll Make :

1. Berechnen Sie alle Entfernungen dieser Beobachtung X zu den anderen Beobachtungen im Datensatz D
2. Halten Sie die K Beobachtungen aus dem Datensatz D fest, die X am nächsten sind, indem Sie die Funktion zur Berechnung der Distanz d
3. Nehmen Sie die Y-Werte der k ausgewählten Beobachtungen. Führen Sie eine Regression durch und berechnen Sie den Mittelwert (oder Median) von Y. 
4. Geben Sie den in Schritt 3 berechneten Wert als den Wert zurück, der von K-NN für die Beobachtung X vorhergesagt wurde.

Ende Algorithmus

Man muss also den Abstand zwischen zwei Punkten berechnen können. In einem zweidimensionalen Diagramm, wie es in unserem Beispiel der Fall ist, entspricht dies einfach der Norm des Vektors zwischen den beiden Punkten.

Aktivität 1. Schreiben Sie die Funktion distance(point1, point2), die zwei Punkte (point1=[x1,y1], point2=[x2,y2]) als Argumente nimmt und den Abstand zwischen diesen beiden Punkten zurückgibt.

Aktivität 2. Füllen Sie die folgende Tabelle aus, indem Sie den Abstand zwischen den Superpixeln der vorherigen Bilder (forward_0.jpg, forward_1.jpg,...) und der beiden Testbilder (test_0.jpg und test_1.jpg) bestimmen.

‍

Aktivität 3. Wenden Sie die Schritte 3 und 4 des K-NN-Algorithmus mit K=1,2,3 und 4 an und leiten Sie daraus die Entscheidung ab, die getroffen werden muss (geradeaus gehen, nach links abbiegen, nach rechts abbiegen).

‍

‍

Roboterantrieb

Phase der Vorbereitung der Arbeitsumgebung

• Wählen Sie im Menü Einstellungen - > Beispielkonfigurationen laden die Beispielkonfiguration "Überwachtes Lernen - KNN Kamera" aus. 

Achtung: Für dieses Szenario sollten Sie, um den bestmöglichen Kontrast zu erzielen, eine weiße Fläche auf den Boden legen und darauf achten, dass die Arena gleichmäßig beleuchtet ist.

‍

Trainingsphase

Aktivität 1. Befolgen Sie das Protokoll, um die Trainingsphase zu absolvieren.

‍

Sie sind nun mit dem Roboter verbunden und Ihr Bildschirm sollte wie im Bild unten aussehen. Sein Batteriestand sollte unten rechts angezeigt werden (vergewissern Sie sich, dass der Roboter aufgeladen ist).

• Solange der Roboter Platz hat, um sich vorwärts zu bewegen, drücken Sie auf geradeaus. 

• Wenn sich der Roboter einer Wand nähert, drücken Sie auf Drehen auf der Stelle nach links oder rechts. 

Bei jeder Anweisung, die an den Roboter gesendet wird, wird dem Diagramm ein neuer Punkt hinzugefügt. Die Abszisse dieses Punktes entspricht dem Wert des linken Superpixels und seine Ordinate dem Wert des rechten Superpixels. Die Farbe jedes Punktes entspricht der gewählten Aktion: gelb für geradeaus, grün für rechts abbiegen und rot für links abbiegen. Diese Punkte sind die Trainingsdaten. Diese Trainingsphase ist von entscheidender Bedeutung, damit die KI richtig lernen kann. Wenn die Trainingsdaten zu viele Fehler oder Annäherungen enthalten, kann es sein, dass das Verhalten der KI nicht zufriedenstellend ist. 

Beachten Sie:

Die Pixel werden dunkler, wenn sich der Roboter den Wänden nähert. Normalerweise sollte man, wenn der linke Pixel am dunkelsten ist, nach rechts abbiegen, und wenn der rechte Pixel am dunkelsten ist, nach links abbiegen. Nachdem Sie einige Punkte auf der Grafik hinzugefügt haben, können Sie auf der Registerkarte "Visualisierungseinstellungen" die Hintergrundfarbe aktivieren. Diese Option färbt jedes Pixel im Diagramm in der Farbe des nächstgelegenen Datenpunkts.

Wenn Sie drei deutliche Regionen auf dem Graphen haben, beenden Sie die Trainingsphase und schalten Sie die Autonomie wieder ein, um mit der Testphase fortzufahren. Zögern Sie nicht, den Roboter von Hand zu bewegen, wenn ein Bereich des Graphen zu wenige Punkte enthält.

‍

‍

Tests

Wenn der Roboter gut trainiert ist, kann er die Kanten selbstständig vermeiden. Wenn er hingegen schlecht trainiert ist oder die Helligkeit in der Arena nicht gleichmäßig ist, wird dies in den erstellten Regionen Lärm erzeugen und der Roboter wird mehr unangemessene Aktionen ausführen.

Beachten Sie:

Um das beste Verhalten des Roboters zu erreichen, müssen Sie mehrere Werte für k testen. Um diesen Wert zu ändern, gehen Sie auf die Registerkarte "KI" und ändern Sie den Wert des Parameters "Anzahl der Nachbarn".

Ein guter Wert für k verringert die Wirkung von Rauschen und ermöglicht es dem Roboter, besser mit unerforschten Gebieten umzugehen.

Wenn der Roboter gut trainiert ist und die Tests gut verlaufen, können Sie mit den Aktivitäten fortfahren.

‍

Aktivität 1. Vergleiche das Verhalten des Roboters bei k=1, k=3, k=10 und k=30. Versuchen Sie dann, anhand Ihrer Beobachtungen den Wert für k zu bestimmen, der den Effekt der Fehler minimiert und das beste Roboterverhalten ergibt, d. h. die größte Distanz, die der Roboter zurücklegt, ohne gegen eine Wand zu stoßen. Der richtige Wert wird von der Anzahl der Datenpunkte und der Anzahl der Fehler in diesen Daten abhängen.

‍

Aktivität 2. Nachdem Sie den Algorithmus nun verstanden haben, versuchen Sie, den Roboter mit so wenigen Daten wie möglich zu trainieren, die es ihm ermöglichen, sich zu drehen, ohne gegen die Wände zu schlagen. 

‍

Erstellen Sie zunächst eine theoretische Version, indem Sie die Bereiche zeichnen, die Sie auf Ihrem Diagramm haben möchten. Welche Punkte müssen Sie setzen, um sie zu erstellen? Testen Sie diese Punkte mit dem Roboter, nachdem Sie sie in die Software eingegeben haben. War Ihr theoretisches Modell in der Realität anwendbar oder mussten Sie Änderungen vornehmen? Welche Einschränkungen hat diese Methode für einen Roboter wie diesen?

Tipp: Sie können den Roboter mit der Hand bewegen, um die Punkte auszuwählen, die Sie ihm beibringen möchten.

Hinweis: Wir haben es geschafft, dem Roboter mit nur 3 Punkten beizubringen, sich in der Arena zu bewegen, ohne gegen die Wände zu schlagen.

Weiterführende Informationen :

‍

Aktivität 3. Wenn Sie noch Zeit haben und experimentieren möchten, wechseln Sie den Algorithmus und schauen Sie, welche Unterschiede der Roboter in seinem Verhalten im Vergleich zu KNN aufweist. Welcher andere Algorithmus schlägt ein schnelleres Lernen vor? Und welcher andere Algorithmus würde Ihrer Meinung nach das Lernen komplexerer Aufgaben ermöglichen, z. B. das Kicken eines grünen Balls oder das Erkennen von Befehlen, die mit Handzeichen kommuniziert werden?

‍

‍

Programmieren des Algorithmus der K nächsten Nachbarn

1. Stoppen Sie den Roboter und aktivieren Sie wieder die Taste "Autonom".

2. Wählen Sie auf der Registerkarte AI die Option Algorithmus: Schülercode , woraufhin sich ein neues Fenster öffnet, in dem Sie aufgefordert werden, der Datei einen Namen zu geben. 

3. Nachdem Sie ihr einen Namen gegeben haben, erscheint die Datei im Windows Explorer: Öffnen Sie sie in Ihrem bevorzugten Code-Editor (z. B. Spyder).

Dieser Code stellt drei bereits vorhandene Funktionen vor: init, learn und take_decision. Diese Funktionen werden von der Hauptsoftware aufgerufen. Nur die Funktion take_decision ist für dieses TP wichtig.

4. Beachten Sie, dass beim Trennen der Verbindung ein simulierter Mini-Roboter in der unteren rechten Ecke erscheint. Wenn Sie möchten, können Sie die Fragen unten mit diesem Mini-Roboter beantworten und am Ende der Übung zum echten Roboter zurückkehren; Sie können aber auch die gesamte Übung durchführen, während Sie mit dem echten Roboter verbunden bleiben: ganz wie es Ihnen gefällt!

‍

‍

DEN ROBOTER DIREKT PROGRAMMIEREN

Bevor wir eine künstliche Intelligenz programmieren, sollten wir zunächst das Prinzip der Funktion take_decision verstehen. Sie werden diese Funktion ändern können, um das Verhalten des Roboters zu verändern: Speichern Sie nach jeder Änderung Ihren Code und klicken Sie auf die Schaltfläche "KI zurücksetzen". Diesen Schritt sollten Sie bei jeder Änderung des Codes wiederholen: Speichern und dann den Code neu laden.

Die Funktion hat den folgenden Prototypen:

take_decisionsensors:listint

Die Eingabe sensors ist der Zustand der Sensoren des Roboters, d. h. in unserem Fall eine Liste mit den beiden Werten sensors[0] und sensors[1], die die Intensität dessen darstellen, was der Roboter links und rechts von sich sieht. Seine Ausgabe ist die Nummer der gewählten Aktion.

1. Fügen Sie die Anweisung print(sensors) innerhalb der Funktion ein. Speichern Sie, klicken Sie in der Software auf "KI zurücksetzen" und starten Sie den Roboter. Der Wert von sensors wird nun in der Konsole angezeigt (klicken Sie in der Taskleiste auf das Symbol, um die Konsole anzuzeigen). Wie hoch ist der Wert von sensors ungefähr, wenn der Roboter vor einer Wand steht? wenn er nicht vor einer Wand steht? wenn sich links oder rechts von ihm eine Wand befindet?

‍

2. Zurzeit gibt die Funktion 0 zurück. Welchen Wert muss die Funktion zurückgeben, damit der Roboter geradeaus fährt? (Machen Sie den Versuch)

‍

3. Verwenden Sie die Variable x, um ein konsistentes Verhalten des Roboters zu programmieren: "Wenn es keine Wand gibt, gehe ich geradeaus; wenn es eine Wand gibt, drehe ich mich um."

‍

‍

ALGORITHMUSPROGRAMMIERUNG

Berechnung der Entfernung

Falls Sie es nicht bereits in der vorherigen Aktivität getan haben, programmieren Sie eine neue Funktion distance, die als Argumente zwei Punkte a und b nimmt, die zwei Arrays aus zwei Elementen sind, die jeweils ihre Koordinaten enthalten, und die den euklidischen Abstand dieser beiden Punkte zurückgibt. Der Prototyp der Funktion lautet wie folgt:

distancea:list, b:listfloat

Mit a=x1, y1 und b=x2, y2

Zur Erinnerung: Der euklidische Abstand zwischen diesen beiden Punkten ist: d=x2-x12+y2-y12.

Die Quadratwurzel kann in Python verwendet werden, indem man die math (oder numpy) Bibliothek am Anfang der :

import math

und wird so geschrieben:

y = math.sqrt(x)

Der quadratische Operator kann folgendermaßen hergestellt werden:

y = x**2

4. Programmieren Sie die neue Funktion distance. Um sie dann zu testen, schreiben Sie unten in der Datei :

# compute distance

a = [0, 0]
b = [1, 2]
print("distance", distance(a, b))

Speichern Sie, laden Sie den Code mit "KI zurücksetzen" und notieren Sie unten das Ergebnis, das in der Konsole angezeigt wird :

‍

Berechnung aller Entfernungen

Da Sie nun eine Methode zur Berechnung einer Entfernung haben, schreiben Sie eine neue Funktion all_distances, die alle Entfernungen von einem Punkt in Bezug auf die Variable train_sensors berechnet, die die Eingabedaten für das Training sind. Diese Funktion nimmt als Argument einen neuen Punkt x, der wie zuvor eine Liste mit zwei Elementen ist, und gibt ein Array zurück, das alle diese Entfernungen enthält. Ihr Prototyp ist :

all_distances(a:list[float], train_sensors:list[list[float]]])→list[float]

Mit a=x0, y0 und train_sensors=x1, y1, x2, y2, ..., xn, yn Wobei das Array train_sensors die Länge n hat.

‍

5. Programmieren Sie all_distances und testen Sie mit dem folgenden Code am Ende der Datei :

# compute all distances

a = [0.4, 0.6]

train_sensors = [[0, 0], [0, 1], [1, 0]]

distance_list = all_distances(a, train_sensors)

print('distances to data', distance_list)

Laden Sie den Code neu und kopieren Sie Ihr Ergebnis :

‍

Das kleinste Element eines Arrays finden

Erstellen Sie eine Funktion mit dem Namen find_minimum, die als einziges Argument ein Array verwendet und den Index des ersten kleinsten Elements zurückgibt. Ihr Prototyp ist :

find_minimum(dlist:listfloat)→int

6. Programmieren und testen Sie find_minimum mit dem folgenden Code:

# minimum in a list

idx_min = find_minimum(distance_list)

print('index of minimum', idx_min)

Beachten Sie das Ergebnis :

‍

Der nächste Nachbar

Da wir nun alle notwendigen Funktionen haben, können wir die Funktion nearest_neighbor_decision erstellen, die als Argument die Trainingsdaten und den aktuellen Kameraeingang nimmt und den Befehl zurückgibt, der an den Roboter gesendet werden soll. Ihr Prototyp ist :

nearest_neighbor_decision(train_sensors:list[listfloat],train_decisions:list[int],a:list[float])→int

Wie zuvor a=x0, y0 und train_sensors=x1, y1, x2, y2, ..., xn, yn und train_decisions = d1,...,dn, wobei jedes di die Entscheidung ist, die für den Punkt xi, yi in der Tabelle train_sensors getroffen wurde . 

Um die Funktion auszuführen, berechnen Sie die Entfernungen, finden Sie die kürzeste und geben Sie den zugehörigen Befehl mithilfe von train_decisions zurück.

‍

7. Programmieren und testen Sie nearest_neighbors_decision mit dem folgenden Code:

# KNN

a = [0.4, 0.6]

train_sensors = [[0, 0], [0, 1], [1, 0]]

train_decisions = [1, 2, 0].

decision = nearest_neighbor_decision(train_sensors, train_decisions, a)

print('KNN', decision)

Kopieren Sie das Ergebnis :

‍

‍

VERWENDUNG IHRES ALGORITHMUS MIT DEM ROBOTER 

Herzlichen Glückwunsch, Sie haben den Algorithmus der K nächsten Nachbarn im Fall K=1 selbst programmiert. Jetzt müssen Sie ihn nur noch im Programm verwenden, um den Roboter zu trainieren.

Kopieren Sie dazu die folgenden Zeilen, um die Funktion take_decision zu programmieren, um die richtigen Entscheidungen zu treffen, aber auch learn, um sich an die Trainingsdaten train_sensors und train_decisions zu erinnern, die nach und nach im Hauptprogramm erstellt werden:

train_sensors = train_decisions = None

def learn(X_train, y_train):
global train_sensors, train_decisions
train_sensors, train_decisions = X_train, y_train
loss = 0
return loss

def take_decision(sensors):
if train_sensors is None:
return 0
return nearest_neigbor_decision(train_sensors, train_decisions, sensors)

 Und jetzt können Sie Ihren Roboter trainieren!

1. Code aufladen

1. Deaktivieren Sie die Autonomie des Roboters, indem Sie auf das Symbol

1. ,
2. Lenken Sie den Roboter, indem Sie auf die Pfeile auf der rechten Seite des Bildschirms klicken. Drehen Sie sich, wenn sich der Roboter in der Nähe von Wänden befindet, und gehen Sie ansonsten geradeaus. 

Die Tabellen train_sensors und train_decisions werden jedes Mal, wenn Sie einen Pfeil anklicken, automatisch von der Software ausgefüllt.

4. Nach einer kurzen Lernphase reaktivieren Sie die Autonomie

4. Der Roboter navigiert allein durch die Arena. Weicht er selbstständig den Wänden aus?

‍

‍

Weiterführende Informationen

Der Algorithmus, den Sie geschrieben haben, verwendet den nächsten Nachbarn, um eine Entscheidung zu treffen. Ändern Sie Ihren Code so, dass er die Mehrheit der Entscheidungen berücksichtigt, die zwischen einer Zahl k>1, k∈N getroffen werden. Die Schwierigkeit besteht darin, die Funktion, die das Minimum findet, zu ändern. Sie muss nun k und nicht nur 1 finden.

‍

‍

Bilanz und Feedback

‍

In der Programmierung wird die Liste der zugänglichen Funktionen eines Programms als API bezeichnet, was für Application Programming Interface(Schnittstelle zur Anwendungsprogrammierung) steht. Sie wird von Programmierern verwendet, um herauszufinden, wie sie mit dem Programm interagieren können. Die API des Python-Moduls alphai finden Sie unter folgendem Link: https: //drive.google.com/file/d/1C4ovPW_eH5KFz5Y9JvSrzLhtmdOpcp6-/view