[PYTHON] Versuchen Sie Deep Learning mit FPGA

Einführung

Mit der Veröffentlichung eines Projekts namens BNN-PYNQ durch Xilinx können selbst Anfänger von FPGA Deep Learning problemlos auf FPGA ausführen. Ich kaufte sofort ein Board und versuchte es, bis die Demo ausgeführt wurde.

Vorherige Erklärung

PYNQ Es scheint sich um ein Xilinx-Open-Source-Projekt zu handeln, das die Verwendung der in Xilinxs Zynq von Python implementierten FPGA-Logik vereinfacht.

Wenn ein Programm in Zynq ausgeführt wird, wird es normalerweise in PS (Processing System), das von der CPU ausgeführt wird, und PL (Programmable Logic), das vom FPGA ausgeführt wird, unterteilt. Ist es in Deep Learning ein Bild der Implementierung einer Anwendung, die Deep Learning auf PS verwendet, und der Implementierung einer Faltungsverarbeitung, von der erwartet werden kann, dass sie durch Parallelisierung und Berechnungsverarbeitung jeder Schicht des neuronalen Netzwerks auf PL beschleunigt wird? Mit PYNQ können Sie PS in Python schreiben.

Darüber hinaus hat es als Hauptmerkmal die Idee der Überlagerung. Mit Overlay können Sie den PL-Teil von Python dynamisch ändern, indem Sie den PL wie eine Softwarebibliothek behandeln. Wenn Sie beispielsweise MNIST ausführen, laden Sie einfach das MNIST-Overlay in Python, und das MNIST-Netzwerk wird auf PL erweitert.

Einzelheiten zu PYNQ finden Sie im Folgenden.

• Introduction to Overlays
• PYNQ-Z1-Overlay lesen und FPGA PL von Python aus steuern
• FPGA Extreme Computing Extra Edition: PYNQ Festival

PYNQ-Z1 Board Das Board, das das PYNQ-Projekt offiziell unterstützt, ist das PYNQ-Z1-Board. Es ist mit Dual-Core ARM® Cortex®-A9 ausgestattet. Es hat auch HDMI IN / OUT, so dass es für die Bild- und Videoverarbeitung nützlich zu sein scheint.

PYNQ: PYTHON PRODUCTIVITY ON ZYNQ

Derzeit scheint es nicht möglich zu sein, in Japan zu kaufen, daher habe ich es von der Digilent-Website gekauft. Der Betrag beträgt ca. 30.000 Yen inklusive Versandkosten und ist in ca. einer Woche nach Bestellung angekommen. Die Lieferung erfolgte durch FedEx, aber ich erhielt eine Steuerrechnung (ca. 1.500 Yen) getrennt vom Produkt. Ich konnte die Rechnung im Supermarkt bezahlen.

BNN-PYNQ BNN-PYNQ ist ein Projekt, mit dem Sie Binarized Neural Network (BNN) auf PYNQ ausführen können. Deep Learning besteht aus Inferenz und Lernen, aber nur Inferenz wird in BNN-PYNQ veröffentlicht.

Algorithmus

In FPGA scheint es aufgrund der Begrenzung der Rechenressourcen Mainstream zu sein, einen binärisierten Algorithmus zu verwenden. Durch die Binärisierung wird es auch zur XNOR-Berechnung, und es scheint, dass eine Beschleunigung erwartet werden kann. In BNN-PYNQ werden CNV und LFC als Überlagerung von PYNQ veröffentlicht. Es ist gewesen.

Weitere Informationen zu BNN finden Sie in der Zeitung. In Bezug auf den Binärisierungsalgorithmus ist Folgendes hilfreich.

• [Survey]Binarized Neural Networks: Training Deep Neural Networks with Weights and Activations Constrained to +1 or -1
• GPU und Gachinko kämpfen mit binarisiertem CNN auf FPGA (öffentliche Version)
• BinaryNet und Binarized Deep Neural Network

Implementierung

BNN-PYNQ implementiert Deep Learning mithilfe einer Bibliothek namens xilinx-tiny-cnn. xilinx-tiny-cnn basiert auf tiny-dnn, und die folgenden Punkte wurden geändert. BNN-PYNQ verwendet tiny-dnn.

• added batchnorm layer (currently feedforward only, no training)
• support for offloaded layer
• interleave layer
• binarized layers

Der Entwickler von tiny-dnn scheint Japaner zu sein. Es ist wunderbar. .. .. Einführung von Deep Learning, tiny-dnn nur mit C ++ - Header

Führen Sie die Demo aus

Umgebung

Um BNN-PYNQ auszuführen, haben wir Folgendes vorbereitet.

• PYNQ-Z1 Board
• Micro-SD-Karte (8 GB oder mehr empfohlen)
• LAN-Kabel
• USB-Kabel Wird für die Stromversorgung verwendet. Ich denke das Netzteil ist besser.
• Mac mini
  Es wird verwendet, um das PYNQ-Image auf eine SD-Karte zu brennen und den PYNQ Jupyter zu öffnen.

Grundeinstellung von PYNQ

Befolgen Sie die Dokumentation für Erste Schritte (https://pynq.readthedocs.io/en/latest/1_getting_started.html).

Ein Bild erstellen

Laden Sie zuerst das Bild herunter. Download von "Download und das PYNQ-Z1-Image" im Verfahren im obigen Dokument. Sie können es auch von [Digilents Website] herunterladen (https://reference.digilentinc.com/reference/programmable-logic/pynq-z1/start). (Ich kenne den Unterschied nicht) Zum Zeitpunkt des Schreibens des Artikels wurde pynq_z1_image_2017_02_10.zip heruntergeladen.

Entpacken Sie die heruntergeladene ZIP-Datei "PYNQ-Z1 Image".

$ tar zxvf pynq_z1_image_2017_02_10.zip
x pynq_z1_image_2017_02_10.img

Installieren Sie das entpackte Image auf der SD-Karte. Überprüfen Sie zunächst die SD-Karte, auf der Sie das Image installieren möchten.

$ df -ah
Filesystem      Size   Used  Avail Capacity   iused    ifree %iused  Mounted on
/dev/disk1s1    30Gi  2.5Mi   30Gi     1%         0        0  100%   /Volumes/UNTITLED

Formatieren Sie die SD-Karte mit FAT32.

$ diskutil eraseDisk FAT32 PYNQ /dev/disk1
Started erase on disk1
Unmounting disk
Creating the partition map
Waiting for the disks to reappear
Formatting disk1s2 as MS-DOS (FAT32) with name PYNQ
512 bytes per physical sector
/dev/rdisk1s2: 62501024 sectors in 1953157 FAT32 clusters (16384 bytes/cluster)
bps=512 spc=32 res=32 nft=2 mid=0xf8 spt=32 hds=255 hid=411648 drv=0x80 bsec=62531584 bspf=15260 rdcl=2 infs=1 bkbs=6
Mounting disk
Finished erase on disk1

Hängen Sie die SD-Karte aus.

• Entfernen Sie die SD-Karte nicht.

$ diskutil unmountDisk /dev/disk1
Unmount of all volumes on disk1 was successful

Schreiben Sie das vorherige Bild auf die SD-Karte.

$ sudo dd bs=1024m if=pynq_z1_image_2017_02_10.img of=/dev/rdisk1
Password:

Die SD-Karte ist jetzt fertig!

Anlaufen

Stellen Sie die PYNQ-Karte gemäß der Abbildung unten ein.

⓪ Stellen Sie sicher, dass der Netzschalter ausgeschaltet ist ① Stellen Sie JP4 (neben USB HOST) auf SD ② Legen Sie die zuvor erstellte SD-Karte ein ③ Schließen Sie das USB-Kabel (Netzkabel) an. ④ Schließen Sie das LAN-Kabel an

In meinem Fall habe ich JP5 (neben dem Netzschalter) zusätzlich zu den oben genannten auf USB geändert, da die Stromversorgung über USB erfolgt. Nachdem Sie alles eingestellt haben ...

⑤ Schalten Sie PYNQ ein

Jupyter Notebook / SSH In PYNQ wird Jupyter Notebook ausgeführt. Daher können Sie Python auf Jupyter Notebook programmieren, indem Sie auf den folgenden Link zugreifen.

http://[PYNQのIPアドレス]:9090

Wenn Sie zum ersten Mal darauf zugreifen, wird die Anmeldeseite unten angezeigt. Das Passwort lautet "xilinx".

Die Verwendung ist die gleiche wie bei normalem Jupyter.

Sie können auch über SSH auf PYNQ zugreifen. Der Kontoname lautet "xilinx" und das Passwort lautet "xilinx".

Führen Sie den folgenden Befehl aus, um PYNQ zu aktualisieren.

xilinx@pynq:~$ sudo /home/xilinx/scripts/update_pynq.sh
[sudo] password for xilinx: 
Info: This operation will overwrite all the example notebooks
Press any key to continue...

Github Repo Detected. Pulling latest changes from upstream..
fatal: A branch named 'master' already exists.
Already on 'master'
Your branch is up-to-date with 'origin/master'.
remote: Counting objects: 13, done.
remote: Compressing objects: 100% (13/13), done.
remote: Total 13 (delta 2), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (13/13), done.
From https://github.com/Xilinx/PYNQ
   3ed304a..0309566  master     -> origin/master
Updating 3ed304a..0309566
Fast-forward
 python/pynq/gpio.py            | 210 ++++++++++++++++++++++++++++++++++++++----------------
 python/pynq/iop/iop.py         |  22 +++---
 python/pynq/tests/test_gpio.py |   1 +
 3 files changed, 161 insertions(+), 72 deletions(-)

checking out v1.4

Verifying current SDCard image supports this pynq release.
Completed

Build libsds_lib

cd /home/xilinx/pynq_git/scripts/xlnkutils && make && make install
make[1]: Entering directory '/home/xilinx/pynq_git/scripts/xlnkutils'
gcc wrapper.c -fPIC -shared -rdynamic -o libsds_lib.so -Wl,--whole-archive libsds_lib.a -l pthread  -Wl,--no-whole-archive
make[1]: Leaving directory '/home/xilinx/pynq_git/scripts/xlnkutils'
make[1]: Entering directory '/home/xilinx/pynq_git/scripts/xlnkutils'
cp -avf libsds_lib.so /usr/lib/
‘libsds_lib.so’ -> ‘/usr/lib/libsds_lib.so’
cp -arvf libxlnk_cma.h /usr/include/
‘libxlnk_cma.h’ -> ‘/usr/include/libxlnk_cma.h’
make[1]: Leaving directory '/home/xilinx/pynq_git/scripts/xlnkutils'

Pip install latest pynq python package

python3.6 /home/xilinx/scripts/stop_pl_server.py
rm -rf /opt/python3.6/lib/python3.6/site-packages/pynq/*
cp -rf /home/xilinx/pynq_git/Pynq-Z1/sdk/bin/*.bin /home/xilinx/pynq_git/python/pynq/iop/
cp -rf /home/xilinx/pynq_git/Pynq-Z1/bitstream /home/xilinx/pynq_git/python/pynq/
cd /home/xilinx/pynq_git/python ; sudo -H python3.6 -m pip install --upgrade .
Processing /home/xilinx/pynq_git/python
Installing collected packages: pynq
  Found existing installation: pynq 1.4
    Uninstalling pynq-1.4:
      Successfully uninstalled pynq-1.4
  Running setup.py install for pynq ... done
Successfully installed pynq-1.4
python3.6 /home/xilinx/scripts/start_pl_server.py &

Update scripts and notebooks

cp -arf /home/xilinx/pynq_git/Pynq-Z1/notebooks/* /home/xilinx/jupyter_notebooks
cp -f /home/xilinx/pynq_git/scripts/linux/rc.local /etc/
mkdir -p /home/xilinx/jupyter_notebooks/getting_started
mkdir -p /home/xilinx/jupyter_notebooks/getting_started/images
cp /home/xilinx/pynq_git/docs/source/3_jupyter_notebook.ipynb \
/home/xilinx/jupyter_notebooks/getting_started/1_jupyter_notebook.ipynb
cp /home/xilinx/pynq_git/docs/source/4_programming_python.ipynb \
/home/xilinx/jupyter_notebooks/getting_started/2_programming_python.ipynb
cp /home/xilinx/pynq_git/docs/source/5_programming_onboard.ipynb \
/home/xilinx/jupyter_notebooks/getting_started/3_programming_onboard.ipynb
cp /home/xilinx/pynq_git/docs/source/8_base_overlay_iop.ipynb \
/home/xilinx/jupyter_notebooks/getting_started/4_base_overlay_iop.ipynb
cp /home/xilinx/pynq_git/docs/source/9_base_overlay_video.ipynb \
/home/xilinx/jupyter_notebooks/getting_started/5_base_overlay_video.ipynb
cp /home/xilinx/pynq_git/docs/source/10_base_overlay_audio.ipynb \
/home/xilinx/jupyter_notebooks/getting_started/6_base_overlay_audio.ipynb
chown -R xilinx:xilinx /opt/python3.6/lib/python3.6/site-packages/pynq/*
chmod -R a+rw /home/xilinx/jupyter_notebooks /opt/python3.6/lib/python3.6/site-packages/pynq
chmod -R a+x /home/xilinx/scripts/*
chmod a+x /root/*.sh
chmod a+x /etc/rc.local
chown -R xilinx:xilinx /home/xilinx/jupyter_notebooks /home/xilinx/scripts /opt/python3.6/lib/python3.6/site-packages/pynq
Notebooks     folder is at: /home/xilinx/jupyter_notebooks
Scripts       folder is at: /home/xilinx/scripts

Completed PYNQ update.

xilinx@pynq:~$ 

Es wurde PYNQ 1.4.

BNN-PYNQ-Installation

Installieren Sie BNN-PYNQ. Es wird in [Schnellstart] von BNN-PYNQ (https://github.com/Xilinx/BNN-PYNQ#quick-start) beschrieben, Sie können es jedoch mit dem folgenden Befehl installieren.

xilinx@pynq:~$ sudo pip3.6 install git+https://github.com/Xilinx/BNN-PYNQ.git
[sudo] password for xilinx: 
The directory '/home/xilinx/.cache/pip/http' or its parent directory is not owned by the current user and the cache has been disabled. Please check the permissions and owner of that directory. If executing pip with sudo, you may want sudo's -H flag.
The directory '/home/xilinx/.cache/pip' or its parent directory is not owned by the current user and caching wheels has been disabled. check the permissions and owner of that directory. If executing pip with sudo, you may want sudo's -H flag.
Collecting git+https://github.com/Xilinx/BNN-PYNQ.git
  Cloning https://github.com/Xilinx/BNN-PYNQ.git to /tmp/pip-7pt0wn6t-build
Installing collected packages: bnn-pynq
  Running setup.py install for bnn-pynq ... done
Successfully installed bnn-pynq-0.1

BNN-PYNQ ausführen

Wenn die Installation abgeschlossen ist, sollten Sie einen BNN-Ordner auf Jupyter haben. In diesem Ordner werden einige Beispiele vorbereitet.

Von hier aus möchte ich Cifar10 ausführen. Cifar10 ist ein Beispiel, das Bilder in 10 Typen klassifiziert. Versuchen Sie vorerst [Alle ausführen].

Alles war erledigt. Wie Sie anhand des Quellcodes sehen können, lädt Python nur das abgeleitete Bild und ruft classify_image auf.

Das Vergleichsergebnis der Geschwindigkeit nach CPU und FPGA wird an folgender Stelle angezeigt.

Die CPU von PYNQ mag langsam sein, aber der Unterschied beträgt mehr als das 360-fache.

 4.BNN in Hardware starten → FPGA verwenden
    2223.00 microseconds
 5.BNN in der Software starten → Nur CPU verwenden
    817744.00 microseconds

Quellcode

Werfen wir einen kurzen Blick auf bnn.py von BNN-PYNQ, das von PIP installiert wurde.

Zunächst erfolgt die Initialisierung der CnvClassifier-Klasse.

class CnvClassifier:
    def __init__(self, params, runtime=RUNTIME_HW):
        self.bnn = PynqBNN(runtime, network=NETWORK_CNV)
        self.bnn.load_parameters(params)

Hier laden wir PynqBNN-Instanziierungs- und Netzwerklernparameter.

Als nächstes folgt die Initialisierung der PynqBNN-Klasse.

class PynqBNN:
    
    def __init__(self, runtime=RUNTIME_HW, network=NETWORK_CNV, load_overlay=True):
        self.bitstream_name = None
        if runtime == RUNTIME_HW:
            self.bitstream_name="{0}-pynq.bit".format(network)
            self.bitstream_path=os.path.join(BNN_BIT_DIR, self.bitstream_name)
            if PL.bitfile_name != self.bitstream_path:
                if load_overlay:
                    Overlay(self.bitstream_path).download()
                else:
                    raise RuntimeError("Incorrect Overlay loaded")
        dllname = "{0}-{1}.so".format(runtime, network)
        if dllname not in _libraries:
            _libraries[dllname] = _ffi.dlopen(
		os.path.join(BNN_LIB_DIR, dllname))
        self.interface = _libraries[dllname]
        self.num_classes = 0

Hier wird Overlay entsprechend dem angegebenen Netzwerk geladen. Übrigens scheint es in "Overlay (self.bitstream_path) .download ()", dass die Bitstream-Datei gelesen und in die Gerätedatei "/ dev / xdevcfg" geschrieben wird. Lesen von PYNQ-Z1 Overlay und Steuern von FPGA PL aus Python

Außerdem wird die gemeinsam genutzte Bibliothek geladen, um auf das FPGA zuzugreifen. In BNN-PYNQ verwenden Sie FPGA über die gemeinsam genutzte Bibliothek, indem Sie mit cffi.FFI.dlopen auf die gemeinsam genutzte Bibliothek zugreifen.

Schließlich die Folgerung der PynqBNN-Klasse.

    def inference(self, path):
        usecperimage = _ffi.new("float *") 
        result_ptr = self.interface.inference(path.encode(), _ffi.NULL, len(self.classes), usecperimage)
        print("Inference took %.2f microseconds" % (usecperimage[0]))
        print("Classification rate: %.2f images per second" % (1000000.0/usecperimage[0]))
        return result_ptr

Ich rufe "self.interface.inference" auf, um daraus zu schließen. Die zuvor angezeigte Inferenzzeit scheint hier "gedruckt" worden zu sein.

abschließend

Derzeit nur Inferenz, aber ich konnte Deep Learning auf FPGA durchführen. Es war viel schneller als die CPU. Da es auch mit Python (Jupyter Notebook) verwendet werden kann, dachte ich, es wäre einfach, es in eine Anwendung einzubetten oder zu testen.

Da ich PL diesmal nicht berührt habe, hatte ich nicht wirklich das Gefühl, FPGA zu verwenden. Der Quellcode nach der gemeinsam genutzten Bibliothek ist ebenfalls öffentlich zugänglich, und die [Wiederherstellungsmethode](https: // github). com / Xilinx / BNN-PYNQ # Hardware-Design-Rebuilt) ist ebenfalls aufgeführt, daher möchte ich einen Blick darauf werfen.

PYNQ wurde vorgestellt und es war ein sehr interessanter Artikel. Warum Softwareentwickler 2017 FPGA lernen sollten, wenn die Zahl der Jobs für maschinelles Lernen / Deep Learning zunimmt