KI für Anfänger (1)

In vielen Bereichen ist die Künstliche Intelligenz auf dem Vormarsch und hält Einzug in viele Geräte und Anwendungen. Für das laufende Jahr werden die weltweiten Umsätze mit Unternehmensapplikationen im Bereich KI auf 4,8 Milliarden US-$ prognostiziert, in 2025 sollen es schon über 30 Milliarden US-$ sein. Wer sich in diesem Bereich auskennt, erhöht seine Jobchancen, denn KI-Fachleute werden dringend gesucht. Es erfordert zwar etwas Aufwand, sich mit dem Thema zu befassen, man erschließt sich damit aber geradezu neue Welten von möglichen Anwendungen. Nicht zuletzt bereitet das Ganze auch großes Vergnügen.

Unter Künstlicher Intelligenz ist u.a. die Nachbildung eines intelligenten Verhaltens zu verstehen. Ein Teilgebiet davon ist Maschinelles Lernen, bei dem eine Applikation nicht mehr vom Entwickler in allen Einzelheiten durchdacht wird, sondern sich ein universell einsetzbares Programmgerüst in Form eines Neuronalen Netzes (NN) anhand zahlreicher Beispieldaten die erforderlichen Funktionen selbst beibringt. Eine Unterkategorie davon ist Deep Learning (vertieftes Lernen), bei dem sich mittels komplexer und optimierter Programmstrukturen die gelieferten Ergebnisse weiter verbessern. Näheres zu den hier genannten Fachbegriffen finden Sie im weiteren Verlauf dieser kleinen Artikelserie.

Dabei ist KI kein brandneues Thema, sondern existiert bereits seit den 50er Jahren des letzten Jahrhunderts. Der Durchbruch gelang allerdings erst vor wenigen Jahren, als die Rechenleistung von Prozessoren erheblich gesteigert werden konnte. Grafikkarten mit hunderten parallel arbeitenden Rechenwerken und hochspezialisierte KI-Chips ermöglichen nun das Training und die Anwendung von KI-Lösungen. Damit wurde der Weg frei für die in vielen persönlichen Assistenten eingesetzte Spracherkennung sowie die Bilderkennung von Objekten jeglicher Art. Auch beim autonomen Fahren ist der KI eine wesentliche Rolle zugedacht. In Teilbereichen ist die KI bereits heute dem Menschen überlegen, sie schlägt die Weltmeister im Schach- und Go-Spiel und kann z.B. im Gesundheitswesen verlässlicher Tumore erkennen als spezialisierte Fachärzte. Aber keine Sorge, diese Überlegenheit bezieht sich lediglich auf die antrainierten Spezial-Fähigkeiten - das jeweilige Trainingsgebiet gibt auch in Zukunft der Mensch vor.

Preisgünstiger Einstieg

Ein guter und preisgünstiger Einstieg in diese Welt ist der Maixduino, der ausgestattet mit einer Kamera und einem kleinen LCD-Panel gerade einmal rund 30 € kostet (das Kit aus Board, Kamera und Display ist als MAix BiT Kit auch bei Elektor erhältlich, siehe Kasten). Die Platine hat die Bauform eines Arduino Uno, woher sich auch der Name ableitet, sie ist aber sehr viel reichhaltiger ausgestattet. Hergestellt wird das Board von der chinesischen Firma Sipeed. Alternativen zum Maixduino sind z.B. der Jetson Nano von Nvidia, der ROCK PI N10 Model A, der Intel Neural Compute Stick 2 und einige andere, die allerdings in der 100-€-Klasse angesiedelt sind.

Im ersten Teil dieses Artikels stelle ich Ihnen die reichhaltige Hardware des Maixduinos und seine Programmierung mittels der Arduino-IDE vor. Dabei zeige ich neben einigen Arduino-typischen Anwendungen den Einsatz von Kamera und Bildschirm. Als Highlight demonstriere ich abschließend, wie man das Board zur Objekterkennung nutzen kann.

Im zweiten und dritten Teil steigen wir dann vertieft in das Thema KI ein, beschreiben den Aufbau neuronaler Netze, installieren MicroPython und die dazugehörende IDE und zeigen, wie Gesichtserkennung funktioniert. Darüber hinaus wird dargestellt, wie eigene KI-Anwendungen programmiert werden und die Kommunikation mit dem Internet erfolgt.

Ein detaillierter Blick auf den Super-Arduino

Die Spezifikationen des Maixduinos lassen die Herzen von Hardware-Enthusiasten höher schlagen. Größe und Bauform des Boards stimmen weitgehend mit dem Arduino Uno überein, aber man erkennt sofort die höhere Bauteildichte und zahlreiche Zusatzanschlüsse. Im Mittelpunkt stehen zwei große Chips. Zum einen der KI-Prozessor Sipeed M1 mit dem Kendryte K210, auf dessen Innereien ich später zu sprechen komme, sowie ein ESP32 zur Kommunikation über WLAN und Bluetooth und zur Erfassung analoger Signale. Letzterer steuert mit seinen beiden mit 240 MHz getakteten Prozessoren schon eine erhebliche Verarbeitungsleistung bei und entlastet die Hauptprozessoren von lästiger Kommunikationsarbeit. Der ESP32 ist in dieser Zeitschrift schon mehrfach vorgestellt worden, so dass ich hier nicht auf weitere Einzelheiten eingehe.

Die Buchsenleisten entsprechen in Polzahl und Anordnung dem Arduino-Orginal und selbst die Pinbelegung ist weitgehend gleich. Aber Achtung: Die Ein/Ausgänge sind entweder für 3,3 V oder sogar nur für 1,8 V ausgelegt, 5 V wären absolut zerstörerisch!

Weitere Details sind in Bild 1 dargestellt. Zum Anschluss von Kamera und LCD-Panel stehen jeweils 24-polige Buchsen zur Verfügung. Über einen Slot für eine Micro-SD-Karte können dem Maixduino auch große Datenmengen zugänglich gemacht werden. Der USB-Anschluss in zeitgemäßer Typ-C-Technologie dient zur Programmierung und zum Monitoring. Und zur Verarbeitung von Audio-Daten stehen ein digitales Mikrofon sowie ein Audioverstärker mit 3 W Ausgangsleistung und vorgeschaltetem Digital-Analog-Konverter zur Verfügung. Mit dieser reichhaltigen Ausstattung sind sicher zahlreiche Projekte ohne Zusatz-Boards realisierbar.

Ein Blick auf die Pinbelegung (Bild 2) zeigt die starke Verwandtschaft mit dem Original. Die Spannungsversorgung kann über die DC-Buchse oder den Pin VIN mit einer Gleichspannung von 6...12 V erfolgen oder alternativ via USB mit 5 V. Vom ESP32 sind die GPIOs 32...36 und 39 herausgeführt, die alternativ als Analogeingänge A0...A5 nutzbar sind. Auf der gegenüberliegenden Seite befinden sich die Ein/Ausgänge des K210-Moduls.

Sie können mit den gewohnten Arduino-Befehlen angesteuert werden, wobei die Arduino-Pinnummer der Nummer des K210-Ein/Ausgangs entspricht:

#define LED 12            // K210-IO12, Maixduino-Pin 10

pinMode(LED, OUTPUT);     // Port als Ausgang

digitalWrite(LED, HIGH);  // Port auf High-Potential (3,3 V)

Der Pin RST ist ein 1,8-V-Typ und sollte bei externer Beschaltung nicht mit einer höheren Spannung beschickt werden. Die Ausgänge IO36...IO47 sind ebenfalls für den niedrigen Pegel ausgelegt, aber nicht auf Board-Pins herausgeführt, sondern werden intern, z.B. für die LCD-Ansteuerung, genutzt. Die Ports für RX/TX und I2C sind bereits auf dem Board mit passenden Pullup-Widerständen versehen.

Leider spezifiziert das K210-Datenblatt nicht den maximalen Ausgangsstrom der Ausgänge. Er dürfte zwar zur Ansteuerung einer LED mit ca. 10 mA reichen, aber darüber hinaus würde ich ein Treiber-IC einsetzen.

Herzstück: Der Kendryte K210

Das SoC (System-on-a-Chip) K210 der chinesischen Firma Kendryte ist das Herzstück des Maixduinos. Es wird in einer stromsparenden Technologie mit 28 ​nm Rastermaß gefertigt und ist seit September 2018 auf dem Markt. Zur Abwicklung der „normalen“ Arbeitslast stehen zwei 64-Bit-Prozessoren zur Verfügung, die mit 400 ​MHz getaktet sind, wobei eine Übertaktung bis 800 MHz möglich ist. Ihr Inneres basiert auf dem offenen RISC-V-Standard, was dem Hersteller die Lizenzgebühren an die Firma ARM erspart und etwas zu dem niedrigen Verkaufspreis beiträgt. Beide Prozessoren sind zur Unterstützung von Gleitkommaoperationen (einfach und doppelt genau) mit einer FPU (Floating Point Unit) ausgestattet. Bild 3 zeigt die weiteren Innereien dieses Chips im Detail.

Das Besondere am K210 ist seine KPU (Knowledge Processing Unit) zur Abbildung und Berechnung Neuronaler Netze. Er verfügt über eine in diesem Preissektor phänomenale Rechenleistung von 0,46 TOps, das sind 460 Milliarden Instruktionen pro Sekunde. Das ließe sich durch Overclocking noch verdoppeln (womit zum Beispiel eine Erkennungsrate von 60 Objekten pro Sekunde möglich wäre). Diese hohe Verarbeitungsgeschwindigkeit wird von 64 parallel arbeitenden Arithmetik-Einheiten mit einer Bitbreite von 576 erzielt. Dabei ist der Energieverbrauch von 0,3 W im Vergleich zu anderen KI-Systemen sehr gering. So empfiehlt z.B. Nvidia für den Jetson Nano ein Netzteil mit 5 V/4 A = 20 W bei einer vergleichbaren Rechenleistung von 0,4 TOps.

Die KPU kann fortschrittliche Architekturen von Neuronalen Netzen abbilden, z.B. Convolutional Netze, die sich durch ein besonders effizientes Lösungsverfahren auszeichnen und sich aufgrund spezieller Filterverfahren besonders für die Bildauswertung eignen. Dazu mehr im zweiten Artikel. Der im SoC integrierte schnelle Hauptspeicher mit einer Kapazität von 8 MB, aufgeteilt zwischen den Prozessoren und der KPU im Verhältnis 6 zu 2 MB, ermöglicht es, dass bis zu 5,9 MB für Neuronale Netze zur Verfügung stehen. Damit lassen sich durchaus mittelgroße Netze implementieren.

Aber der K210 hat noch weitere Hardware-Schätze zu bieten. Da wäre zum einen der Audio Prozessor (APU) zur Analyse von Audiodaten, besonders hilfreich bei der Vorverarbeitung der Sprachanalyse. Dieser verfügt über 8 Kanäle bzw. 4 Stereo-Kanäle. Eingangssignale lassen sich mit einer Abtastrate von bis zu 192 kHz erfassen und von einer FFT-Einheit (Fast Fourier Transformation) im Hinblick auf das enthaltene Frequenzspektrum zerlegen.

Außerdem sind die Beschleuniger für Verschlüsselungen noch erwähnenswert, der AES Accelerator und SHA256 Accelerator.

Natürlich ist auch die sonst übliche Peripherie an Bord, wie UART, I2C, SPI, I2S, Timer, RTC und PWM.

Sipeed hat das Maixduino-Board zusätzlich mit 16 MB Flash, einer passenden Spannungsversorgung, Mikrofon und 3-W-Verstärker und dem großartigen ESP32 ausgestattet. Hardware-Herz, was willst du mehr? Weitere Informationen über die Inbetriebnahme, die Schaltung und andere Einzelheiten entnehmen Sie bitte den Weblinks [1][2][3].

Software-Entwicklung

Nicht nur die Bauform, sondern auch die Software-Entwicklung ist am Original-Arduino angelehnt, es wird dabei die Arduino-IDE eingesetzt. Zur Erweiterung dieser Entwicklungsumgebung wird wie beim ESP8266 oder ESP32 der Maixduino-Core in die IDE integriert. Dazu gibt man im Menü unter Datei -> Voreinstellungen eine zusätzliche Boardverwalter-URL ein, wobei ein Klick auf den Button rechts neben der Eingabezeile ein kleines Zusatzfenster zur bequemen Eingabe öffnet (Bild 4). Wenn Sie nur den Maixduino programmieren wollen, dann ist lediglich die „sipeed“-Zeile erforderlich, denn der On-Board-ESP32 wird auch darüber programmiert.

Zur Installation des Maixduino-Cores wird über das Menü Werkzeuge -> Board der Boardverwalter aufgerufen. Nach Eingabe des Suchbegriffs „Maix“ (Bild 5) kann die Installation erfolgen.

Und schon können wir mit der Programmierung beginnen. Auf das übliche „Hallo Welt“ verzichte ich hier, wir fangen sofort mit der Überprüfung von Kamera und Bildschirm an. Schließen Sie den Maixduino über USB an und stellen über den Menüpunkt Werkzeuge die Parameter für das Board ein:

Board: Sipeed Maixduino

CPU Clock Frequency: 400 MHz

Burn Tool Firmware: open-ec

Burn Baud Rate: 1.5 Mbps

Tool Install Location: Standard

Port: <Verwendeter COM-Port>

Programmer: k-flash

Ein Demo-Programm zur Bildaufnahme und Wiedergabe auf dem LCD steht bereits in der IDE zur Verfügung; es wird mittels Datei -> Beispiele -> Sipeed_OV2640 -> selfie aufgerufen und nach dem Hochladen (gegebenenfalls die Reset-Taste betätigen) ausgeführt. Den Code sieht man in Bild 6.

Am Programmanfang erfolgt die Definition der benötigten Sipeed-Bibliotheken für Kamera und LCD, die mittels SPI-Bus mit dem Board verbunden sind. Die gewählte Auflösung entspricht dem QVGA-Standard und beträgt 320 * 240 Bildpunkte (farbig, RGB565). In der Setup-Routine erfolgt dann die Initialisierung der beiden Geräte. Und in der endlosen Loop-Schleife werden die aufgenommenen Bilder jeweils unmittelbar auf dem LCD dargestellt. Viel einfacher geht es nicht.

Das Bild ist nicht sonderlich kontrastreich, aber scharf, und die Wiedergabe erfolgt flüssig. In Bild 7 sieht man das Resultat.

Es zeigt sich, dass der Maixduino genauso zugänglich ist wie ein Uno, er bietet jedoch viel mehr Möglichkeiten und man kann sofort mit anspruchsvolleren Applikationen starten.

Ein erstes KI-Modell

Obwohl die Künstliche Intelligenz mit Deep Learning vertieft im zweiten Artikelteil behandelt wird, soll hier bereits eine erste Applikation demonstriert werden. Es handelt sich dabei um die Mobilenet-Demonstration, die nichts mit Mobilfunk zu tun hat, sondern 1000 Objekte aus dem Alltag erkennen und klassifizieren kann. Dazu werden einem Neuronalen Netz, einer Software-Struktur bestehend aus in Schichten angeordneten Knoten, die Bilder der Objekte in einem aufwändigen Trainingsverfahren tausendfach vorgelegt.

Da die Datei mit den Bildern für das Training eine Größe von ca. 200 GB hat und der Anlernvorgang sehr aufwändig ist, wäre dieser auf dem Maixduino kaum durchführbar. Aber es gibt die Möglichkeit, ein bereits trainiertes Modell einzusetzen und unmittelbar mit der Objekterkennung zu beginnen. Genau dies möchte ich jetzt demonstrieren.

Die dazugehörende Software steht unter diesem Link zur Verfügung und enthält folgende Komponenten:

• mobilenet_v1.ino: C++-Hauptprogramm zur Abwicklung der Demo
• MBNet_1000.h: Header-Datei für Demoroutinen
• MBNet_1000.cpp: C++-Routinen für die Erfassung, Erkennung und Darstellung der Objekte
• names.h: Header-Datei für die Objektbezeichnungen
• names.cpp: C++-Routine mit den Bezeichnungen der erkennbaren Objekte

Diese Dateien laden Sie herunter und platzieren Sie alle in einen Ordner. Das bereits trainierte KI-Modell „mobilenet_0x300000.kfpkg“ ist unter diesem Link zu finden, gepackt ist es einige MB groß. Nach dem Entpacken mit 7zip finden Sie einen Ordner „mobilenet_0x300000“ in dem sich zwei Dateien befinden, darunter die Datei „m“ mit dem Modell. Diese kopieren Sie auf eine Micro-SD-Karte in das Root-Verzeichnis (das oberste Verzeichnis) und schieben die Karte in den Maixduino-Slot.

Ein Blick auf den Programmcode in Bild 8 zeigt, dass man mit geringem Aufwand auch sehr komplexe Applikationen programmieren kann. Das liegt natürlich an der hohen Leistungsfähigkeit der Bibliotheken, die im KI-Bereich zahlreich und hocheffizient verfügbar sind. Im ersten Programmteil erfolgen die Einbindung von Kamera, LCD, KPU und der Demoanwendung und danach deren Parametrierung. Dabei wird die Kamera auf das Format der Trainingsbilder eingestellt, nämlich auf 224*224 Pixel. Schließlich erhält das Objekt mbnet die Betriebsmittel KPU, Kamera und LCD zugeordnet.

In der Setup-Routine wird dann die Demonstration gestartet und in der Loop-Schleife erfolgt die Klassifizierung der von der Kamera erfassten Objekte, gefolgt von deren Darstellung auf dem LCD. Viel einfacher kann man eine Objekterkennung nicht programmieren.

Als Testobjekt habe ich dem Maixduino ein Katzenbild präsentiert (Bild 9), das er sofort als gemusterte bzw. ägyptische Katze identifizierte (Bild 10). Die Anwendung klassifiziert ca. 5 Bilder pro Sekunde und wäre damit in der Lage, auch aus der Bewegung heraus nutzbare Resultate zu erzeugen. Dabei sollte allerdings die Beleuchtung gut und der Hintergrund nicht zu verworren sein.

In Bild 10 kann man erkennen, dass die Aufnahme zur Erzielung einer besseren Erkennungsrate nun eine blau-weiße Farbgebung aufweist. Das ist eine oft praktizierte Methode: Statt mit drei Farbebenen eines Bildes arbeitet man einfarbig, um die Anzahl der Bildpunkte und damit den erforderlichen Rechenaufwand zu reduzieren. Der hier praktizierte Einsatz eines bereits trainierten NNs, also Training und Klassifikation auf unterschiedlichen Plattformen, ist in diesem Sektor durchaus üblich. Viele Anwender nutzen zum Training die hohe von AWS, Microsoft Azure oder Google Cloud bereitgestellte Rechenleistung und führen das NN mit geringerem Ressourcenbedarf auf kleineren Plattformen aus. Die Halbleiterindustrie reagiert bereits darauf, so hat Intel kürzlich die Neuronal Network Processors Nervana™ NNP-T und NNP-I angekündigt, wobei die T-Version mit hoher Rechenleistung zum Training und die I-Version mit geringerer Performance für die Inference (Schlussfolgerung bzw. Klassifizierung) ausgelegt sind.

Fortsetzung folgt

Mit der Demonstration einer KI-Anwendung konnte das Thema in diesem Beitrag lediglich angerissen werden, aber ich habe hoffentlich Ihr Interesse für lernende Maschinen geweckt.

Im nächsten Artikel werden Struktur und Funktionsweise eines Neuronalen Netzes näher beleuchtet. Dann kommt eine neue Entwicklungsumgebung auf Sie zu, denn ich möchte Ihnen die Befassung mit Linux und der Programmiersprache Python schmackhaft machen. Denn dort stehen die leistungsfähigsten Bibliotheken und Frameworks zur Verfügung. Diese machen z.B. die Gestaltung eines Neuronalen Netzwerks fast so einfach wie das Zusammenstecken von Legobausteinen. Als zusätzliche KI-Applikation stelle ich die Gesichtserkennung und die Entwicklung eigener NNs vor. Für die Ungeduldigen und Neugierigen unter Ihnen empfehle ich die Lektüre „Neuronale Netze selbst programmieren“ von Tariq Rashid.

----------------------------------------------------------------------------------------------------------------------------------------------------

Wollen Sie weitere Elektor-Artikel lesen? Jetzt Elektor-Mitglied werden und nichts verpassen!

----------------------------------------------------------------------------------------------------------------------------------------------------