IoT-Bereitstellung auf dem Raspberry Pi mit ONNX Runtime

Erfahren Sie, wie Sie mit ONNX Runtime und einem Raspberry Pi Bildklassifizierungen am Edge durchführen, Eingaben von der Gerätekamera erhalten und die Klassifizierungsergebnisse an das Terminal senden.

Wenn Sie noch keinen Raspberry Pi konfiguriert haben, lesen Sie die Dokumentation des Raspberry Pi, um Ihr Gerät einzurichten.

Die Bereitstellung von Modellen auf Edge-Geräten bietet viele Vorteile und Anwendungsfälle. Sehen Sie sich die Liste auf unserer IoT-Tutorial-Startseite an.

Image of Raspberry Pi and camera.

Inhalt

Voraussetzungen
Laden Sie den Quellcode, das ML-Modell herunter und installieren Sie die Pakete
Führen Sie die Inferenz auf dem Raspberry Pi mit dem Skript inference_mobilenet.py aus
Schlussfolgerung
Weitere Beispiele

Voraussetzungen

Raspberry Pi 3 B Board
SD-Karte mit Debian vom Raspberry Pi Imager bespielt
Raspberry Pi Kameramodul oder eine andere kompatible Kamera.
VNC Viewer für Fernzugriff. Optional können Sie das Board an einen Monitor anschließen.
Dieses Tutorial behandelt nicht das Bespielen und Einrichten des Raspberry Pi. Grundlegende Kenntnisse in der Konfiguration und Programmierung mit Python auf dem Raspberry Pi werden erwartet.

Laden Sie den Quellcode, das ML-Modell herunter und installieren Sie die Pakete

Nachdem Sie den Raspberry Pi bespielt und für die Verwendung konfiguriert haben, ist es an der Zeit, sich zu verbinden und den Quellcode auf Ihr Gerät herunterzuladen.

Verbinden Sie sich mit Ihrem Raspberry Pi Gerät

In diesem Tutorial verwenden wir VNC Viewer für den Fernzugriff. Wenn Sie VNC Viewer verwenden möchten, stellen Sie sicher, dass Sie diese Einrichtungsschritte zur Herstellung einer Verbindung befolgen. Sobald VNC auf dem Raspberry Pi aktiviert ist und Sie die VNC Viewer App auf Ihrem Computer heruntergeladen haben, können Sie sich mit dem Gerät verbinden.

Image of VNC Viewer

Laden Sie die Quelle auf Ihren Raspberry Pi herunter. Der Quellcode enthält alles, was Sie für die Inferenz benötigen, einschließlich eines mobilenet ONNX-Modells aus dem Modell Zoo und Klassen imagenet_classes.txt.
```
  git clone https://github.com/cassiebreviu/onnxruntime-raspberrypi.git
```
Navigieren Sie zum Download-Speicherort onnxruntime-raspberrypi und installieren Sie das Paket aus der requirements.txt mit dem folgenden Befehl.
```
  cd onnxruntime-raspberrypi
  pip install -r requirements.txt
```
In diesem Tutorial verwenden wir das Raspberry Pi Kameramodul. Wir möchten die Kamera mit dem bereitgestellten Skript cameratest.py testen. Wenn Sie Probleme mit der Kamera haben, führen Sie sudo apt update sudo apt upgrade aus, um das Board und die Firmware zu aktualisieren.
Konfigurieren und testen Sie die Kamera mit dem folgenden Befehl. Dies erstellt ein Bild namens test.jpg im aktuellen Verzeichnis und öffnet einen Live-Videostream der Kameraausgabe. Drücken Sie ESC, um die Live-Videoausgabe abzubrechen.
```
  python cameratest.py
```

Das Skript cameratest.py finden Sie unten zur Referenz

  import numpy as np
  import cv2

  # Create test image using opencv.
  cap = cv2.VideoCapture(0)
  cap.set(3,640) # set Width
  cap.set(4,480) # set Height

  ret, frame = cap.read()
  frame = cv2.flip(frame, -1) # Flip camera vertically
  cv2.imwrite('test.jpg', frame)
    
  # Start live video feed until `ESC` is pressed to quit.
  while(True):
      ret, frame = cap.read()
      frame = cv2.flip(frame, -1) # Flip camera vertically
      gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        
      cv2.imshow('frame', frame)
      cv2.imshow('gray', gray)
        
      k = cv2.waitKey(30) & 0xff
      if k == 27: # press 'ESC' to quit
          break

  cap.release()
  cv2.destroyAllWindows()

Führen Sie die Inferenz auf dem Raspberry Pi mit dem Skript `inference_mobilenet.py` aus

Nachdem wir nun bestätigt haben, dass die Kamera auf dem Raspberry Pi verbunden ist und funktioniert, ist es an der Zeit, das im Quellcode bereitgestellte ONNX-Modell zu inferieren. Das Modell ist ein MobileNet-Modell, das Bildklassifizierungen in 1000 Klassen durchführt.

Führen Sie das Inferenzskript mit dem folgenden Befehl aus.
```
  python inference_mobilenet.py
```
Terminalausgabe:
Das auf dem Raspberry Pi inferierte Bild:

Das Skript inference_mobilenet.py finden Sie unten zur Referenz

  # Import the packages.
  from PIL import Image
  import numpy as np
  import onnxruntime
  import torch
  import cv2

  def preprocess_image(image_path, height, width, channels=3):
      image = Image.open(image_path)
      image = image.resize((width, height), Image.LANCZOS)
      image_data = np.asarray(image).astype(np.float32)
      image_data = image_data.transpose([2, 0, 1]) # transpose to CHW
      mean = np.array([0.079, 0.05, 0]) + 0.406
      std = np.array([0.005, 0, 0.001]) + 0.224
      for channel in range(image_data.shape[0]):
          image_data[channel, :, :] = (image_data[channel, :, :] / 255 - mean[channel]) / std[channel]
      image_data = np.expand_dims(image_data, 0)
      return image_data

  def softmax(x):
      """Compute softmax values for each sets of scores in x."""
      e_x = np.exp(x - np.max(x))
      return e_x / e_x.sum()

  def run_sample(session, image_file, categories):
      output = session.run([], {'input':preprocess_image(image_file, 224, 224)})[0]
      output = output.flatten()
      output = softmax(output) # this is optional
      top5_catid = np.argsort(-output)[:5]
      for catid in top5_catid:
          print(categories[catid], output[catid])
      # Write the result to a file.
      with open("result.txt", "w") as f:
          for catid in top5_catid:
              f.write(categories[catid] + " " + str(output[catid]) + " \r")

  # Create main function to run inference.
  if __name__ == "__main__":
      # Read the categories from the classes file.
      with open("imagenet_classes.txt", "r") as f:
          categories = [s.strip() for s in f.readlines()]
        
      # Create Inference Session
      session = onnxruntime.InferenceSession("mobilenet_v2_float.onnx")

      # Get image from the camera.
      cap = cv2.VideoCapture(0)
      cap.set(3,640) # set Width
      cap.set(4,480) # set Height

      ret, frame = cap.read()
      frame = cv2.flip(frame, -1) # Flip camera vertically
      cv2.imwrite('capture.jpg', frame)
      cap.release()
      cv2.destroyAllWindows()

      # Run inference
      run_sample(session, 'capture.jpg', categories)

Fazit

Nachdem wir erfolgreich Inferenz auf dem Raspberry Pi durchgeführt haben, können wir denselben Code verwenden, um Inferenz auf jedem Gerät auszuführen, das ONNX Runtime unterstützt. Wir können denselben Code auch verwenden, um Inferenz auf dem Raspberry Pi mit einem anderen Modell auszuführen. Sehen Sie sich die anderen Modelle im ONNX Model Zoo an.