[PYTHON] Gesichtserkennung mit Peppers API

Durch die Verwendung der ** ALFaceCharacteristics API **, die in Alterserkennung mit Peppers API eingeführt wurde, können Gesichtsausdrücke wie Lächeln verwendet werden Sie können es erkennen. Hier werden wir zwei Methoden ausprobieren, die von der API bereitgestellte Erkennung des Lächelns und andere Methoden zur Erkennung des Gesichtsausdrucks.

Darüber hinaus verfügt die ** ALFaceCharacteristics-API nicht über eine Möglichkeit, den Betrieb mit einem virtuellen Roboter zu überprüfen, und es ist eine tatsächliche Pepper-Maschine erforderlich. ** Ich möchte, dass Sie mit der eigentlichen Pfeffermaschine im Aldebaran Atelier Akihabara experimentieren. (Reservierungs-URL: http://pepper.doorkeeper.jp/events)

So erhalten Sie die Projektdatei

Die Projektdatei für dieses Tutorial finden Sie unter GitHub https://github.com/Atelier-Akihabara/pepper-face-characteristics-example. Es gibt verschiedene Möglichkeiten, den Code auf GitHub abzurufen. Eine der einfachsten Möglichkeiten besteht darin, das Archiv über den Download-ZIP-Link abzurufen. Es gibt verschiedene andere Methoden, z. B. die Verwendung von Git-bezogenen Tools. Überprüfen Sie diese daher je nach Situation.

Beurteilung des Lächelns

Mithilfe der API "ALFaceCharacteristics" kann der Grad des Lächelns auf dem erkannten Gesicht anhand der Bildmerkmale wie der Feinheit der Augen und der erhabenen Mundwinkel beurteilt werden. Dieser Wert kann verwendet werden, um festzustellen, ob die Person, die Pepper erkennt, lächelt.

Verwenden des Speicherereignisses FaceCharacteristics / PersonSmiling

Der einfachste Weg, einen Lächelncheck durchzuführen, ist die Verwendung des Ereignisses "FaceCharacteristics / PersonSmiling". Lassen Sie uns zunächst den Inhalt des Dokuments überprüfen.

Überprüfen Sie das Dokument

Weitere Informationen zu diesem Ereignis finden Sie in der Choregraphe-Dokumentation unter NAOqi Developer Guide> NAOqi Framework> NAOqi API> NAOqi PeoplePerception> ALFaceCharacteristics> ALFaceCharacteristics API. Wenn Sie auf den Link "FaceCharacteristics / PersonSmiling" klicken, finden Sie die folgende Erklärung.

Event: "FaceCharacteristics/PersonSmiling" callback(std::string eventName, int id, std::string subscriberIdentifier)

Raised when a person has a smile degree above the current threshold (default = 0.7). Parameters:

  • eventName (std::string) – “FaceCharacteristics/PersonSmiling”
  • id – ID of the person as defined by the ALPeoplePerception API.
  • subscriberIdentifier (std::string) –

Es wird erklärt, dass dieses Ereignis auftritt, wenn es eine Person gibt, deren Lächelngrad (ausgedrückt als 0,0 bis 1,0) den Schwellenwert überschreitet (Standard ist 0,7).

Der von diesem Ereignis übergebene Wert ist außerdem "id". Dies ist [ALPeoplePerception: Liste der Personen abrufen](http://qiita.com/Atelier-Akihabara/items/4162192129f366da1240#alpeopleperception-%E4%BA%BA%E3%81%AE%E4%B8%80% E8% A6% A7% E3% 81% AE% E5% 8F% 96% E5% BE% 97) Dies ist die Kennung der Person, die wir bereits gesehen haben. Mit anderen Worten, basierend auf dem Wert, der aus diesem "FaceCharacteristics / PersonSmiling" erhalten wurde, ist es möglich, zusätzliche Informationen über die Person zu erhalten, die festgestellt hat, dass sie lächelt, indem sie "PeoplePerception / Person / / AgeProperties" erwirbt. Ich verstehe das.

Überprüfen der Funktion von Speicherereignissen auf dem Speicherwächter

Überprüfen Sie vor dem Erstellen der Anwendung das Verhalten des Ereignisses mit Memory Watcher. Legen Sie zunächst den Inhalt des Ereignisses, das Sie überprüfen möchten, im Speicher-Watcher fest.

  1. Schließen Sie Choregraphe an die eigentliche Pfeffermaschine an

  2. Doppelklicken Sie im Memory Watcher-Bereich auf ** <Zu überwachender Speicherschlüssel auswählen> ** memory-watcher.png Wenn das Memory Watcher-Bedienfeld nicht angezeigt wird, stellen Sie sicher, dass Memory Watcher im Menü Ansicht aktiviert ist.

  3. Zuerst möchte ich "FaceCharacteristics / PersonSmiling" überprüfen. Geben Sie also PersonSmiling in ** [Filter] [A] ** ein, aktivieren Sie ** [PersonSmiling] unter "FaceCharacteristics" [B] ** und klicken Sie dann auf [ Klicken Sie auf die Schaltfläche OK

    add-person-smiling.png

Dadurch wird Ihrem Memory Watcher "FaceCharacteristics / PersonSmiling" hinzugefügt.

![memory-watcher-2.png](https://qiita-image-store.s3.amazonaws.com/0/54394/9c76f6c8-0a07-60f4-243e-400941e3617e.png)
  1. Überwachen Sie als Nächstes auch "PeoplePerception / VisiblePeopleList", um den Wert der ID der Person zu ermitteln. Geben Sie wie in 3. VisiblePeopleList in ** [Filter] [A] ** ein, aktivieren Sie ** [VisiblePeopleList] unter PeoplePerception [B] ** und klicken Sie auf die Schaltfläche [OK].

    add-visible-people-list.png

Stellen Sie sicher, dass "FaceCharacteristics / PersonSmiling" und "PeoplePerception / VisiblePeopleList" wie unten gezeigt zum Memory Watcher-Bedienfeld hinzugefügt werden.

![memory-watcher-3.png](https://qiita-image-store.s3.amazonaws.com/0/54394/60017d04-c09f-90ab-9b92-aa9589281c3b.png)

Lassen Sie uns nun die Funktionsweise des Speicherereignisses überprüfen. Wenn Sie vor Pepper stehen, sollten Sie die folgenden Änderungen im Inhalt des Speicher-Watchers sehen.

memory-watcher-visible.png

Die Nummer "[6602]" wird in "PeoplePerception / VisiblePeopleList" angezeigt. Dies zeigt an, dass Pepper eine Person in dem Bereich erkennt, den die Kamera erkennen kann, und dass diese Person die Kennung "6602" hat. (Dieser Wert hängt vom internen Status von Pepper zu diesem Zeitpunkt ab.) Als nächstes lachen wir vor Pepper. Versuchen Sie, den Mund zu heben, zu schielen und die Zähne zu zeigen, um ein Lächeln zu zaubern.

memory-watcher-smiling.png

Dann wurde "6602" in "FaceCharacteristics / PersonSmiling" angezeigt. Dies zeigt an, dass Pepper dieses Ereignis ausgelöst hat, als eine Person (Identifikation ist "6602") eine Lächelnstufe von mehr als 0,7 hatte und die Kennung dieser Person auf "FaceCharacteristics / PersonSmiling" gedruckt wurde.

Versuchen Sie, einen Antrag zu stellen

Nachdem Sie die Bewegung von "FaceCharacteristics / PersonSmiling" gesehen haben, erstellen wir mithilfe dieses Ereignisses eine Anwendung. Hier als Beispiel: ** Erstellen Sie eine Anwendung mit der Aufschrift "Können Sie mich auslachen?". Beim Start und wenn ein Lächeln erkannt wird, heißt es "(ID) -san, Sie haben ein schönes Lächeln!" ** Ich werde.

Das Beispielprojekt ist ** Abonnieren-Person-Lächeln **. Von den von GitHub erhaltenen Dateien können Sie sie öffnen, indem Sie im Ordner "subscribe-person-smile" auf "subscribe-person-smile.pml" doppelklicken. Es wird wie folgt erstellt.

  1. Klicken Sie auf die Schaltfläche ** Speicherereignis hinzufügen [+] auf der linken Seite des Flussdiagramms **, geben Sie ** PersonSmiling [A] ** in den Filter ein und aktivieren Sie ** FaceCharacteristics / PersonSmiling [B] ** [OK]. ] Taste subscribe-person-smiling-event.png

  2. Platzieren Sie die folgenden Felder im Flussdiagramm

  1. Verbinden Sie jedes Feld mit dem in 1. erstellten Eingang "FaceCharacteristics / PersonSmiling" und stellen Sie den Inhalt wie folgt ein:

    subscribe-person-smiling-flow.png

  2. [Say Text Text anpassen](http://qiita.com/Atelier-Akihabara/items/8df3e81d286e2e15d9b6#%E8%A3%9C%E8%B6%B3say-text%E3%83%9C%E3%83] % 83% E3% 82% AF% E3% 82% B9% E3% 81% AE% E3% 82% AB% E3% 82% B9% E3% 82% BF% E3% 83% 9E% E3% 82% A4 % E3% 82% BA) und ändern Sie, was Sie sagen

    sentence += str(p) + "Herr, ein schönes Lächeln!"
    

Wenn Sie diese Anwendung ausführen und Ihr Lächeln darauf richten, werden Sie sagen: "12743-san, Sie haben ein schönes Lächeln!" Sobald Sie sich von Pepper entfernen und sich wieder nähern oder wenn sich eine andere Person nähert und lächelt, können Sie auch sehen, dass sie eine andere Kennung spricht, z. B. "16234, Sie haben ein schönes Lächeln!".

Dieses Mal spreche ich zur Erklärung über die Kennung der Person, aber ich denke, es wäre interessant, einfach ein Bild mit FaceCharacteristics / PersonSmiling als Auslöser aufzunehmen, ohne diese Kennung zu verwenden. Bitte nutzen Sie es.

Verwenden von SmileProperties für jede Personen-ID

Ähnlich wie bei der Alterserkennung können Sie den Grad des Lächelns ermitteln, indem Sie die Kennung der Person als Schlüssel verwenden. Im vorherigen Beispiel wurde es möglicherweise nicht unerwartet als Lächeln erkannt. Wenn Sie jedoch dieses Beispiel verwenden, um Ihre eigene Lächelnstufe zu überprüfen, können Sie möglicherweise die Merkmale der Beurteilung der Lächelnstufe in Pepper erkennen.

Die Grundstruktur ist die [Get Age Box](http://qiita.com/Atelier-Akihabara/items/4162192129f366da1240#alfacecharacteristics-%E5%B9%B4%E9%BD%A2%], die im Beispiel für die Alterserfassung eingeführt wurde. Gleich wie E3% 81% AE% E6% 8E% A8% E5% AE% 9A). Versuchen Sie anhand der ID der Person, die Sie im Feld "Grundlegendes Bewusstsein" erhalten haben, auf den Wert "PeoplePerception / Person / / SmileProperties" zu verweisen. Lassen Sie uns als Beispiel eine Person, die von Basic Awareness verfolgt wird, in Intervallen von 10 Sekunden zu einem Lächeln bringen und über diesen Wert sprechen **.

Das Beispielprojekt ist ** get-smile **. Von den von GitHub erhaltenen Dateien können Sie sie öffnen, indem Sie im Ordner "get-smile" auf "get-smile.pml" doppelklicken. Es wird wie folgt erstellt.

  1. Erstellen Sie eine Get Smile-Box als leere Python-Box. Ähnlich wie im Feld "Alter abrufen" verfügt es über die folgende Eingabe- / Ausgabekonfiguration. Informationen zum Erstellen finden Sie unter Python Box-Konzept. get-smile-box.png

  2. Doppelklicken Sie auf das Feld Get Smile, um den Skripteditor zu öffnen und ein Python-Skript wie das folgende zu schreiben.

    class MyClass(GeneratedClass):
        def __init__(self):
            GeneratedClass.__init__(self)
    
        def onLoad(self):
            self.memory = ALProxy("ALMemory")
            self.faceChar = ALProxy("ALFaceCharacteristics")
    
        def onUnload(self):
            pass
    
        def onInput_onPeopleDetected(self, peopleId):
            if peopleId < 0:
                return
            r = self.faceChar.analyzeFaceCharacteristics(peopleId)
            if not r:
                self.onUnknown()
                return
            smileData = self.memory.getData("PeoplePerception/Person/%d/SmileProperties" % peopleId)
            self.logger.info("Smile Properties: %d => %s" % (peopleId, smileData))
            if smileData and len(smileData) == 2:
                self.onSmile(smileData[0])
            else:
                self.onUnknown()
    

Die Codestruktur ähnelt dem Feld Alter abrufen. Der einzige Unterschied besteht darin, dass der von "ALMemory" erhaltene Schlüssel "SmileProperties" anstelle von "AgeProperties" ist.

  1. Stellen Sie auf die gleiche Weise wie im Feld "Alter abrufen" eine Verbindung zum Feld "Grundlegendes Bewusstsein" her. Hier verwenden wir das Feld Timer mit Nummer, bei dem es sich um ein modifiziertes Timer-Feld handelt, sodass der Wert, der schließlich von Basic Awareness ausgegeben wird, alle 10 Sekunden in das Feld Get Smile eingegeben wird. get-smile-flow.png

Die Werte der einzelnen Felder finden Sie im Inhalt der Projektdatei.

Wenn Sie das Get-Smile-Projekt ausführen und Pepper sein Gesicht sehen kann, spricht er alle 10 Sekunden über sein Lächeln, wie unten gezeigt. Wenn Sie versuchen, den Wert des Dezimalpunkts so zu sprechen, wie er ist, ist er schwer zu verstehen, da er als "Zerotenichi" gesprochen wird. Ich spreche also einen ganzzahligen Wert multipliziert mit 100.

Dein Lächeln ist ungefähr 13
Dein Lächeln ist ungefähr 34

Wenn Sie Ihren Gesichtsausdruck ändern, können Sie sehen, dass sich der Wert für die Lächelnstufe ändert. Probieren Sie verschiedene Gesichtsausdrücke aus und experimentieren Sie mit den Faktoren, die Pepper zur Berechnung des Lächelns verwendet.

Wenn Sie sich das Log Viewer-Bedienfeld ansehen, sehen Sie auch den Rohwert der Lächelnstufe und den Wert, der die Genauigkeit anzeigt.

[INFO ] behavior.box :onInput_onPeopleDetected:20 _Behavior__lastUploadedChoregrapheBehaviorbehavior_1892204656__root__GetSmile_5: Smile Properties: 47915 => [0.12999999523162842, 0.09800000488758087]
[INFO ] behavior.box :onInput_onPeopleDetected:20 _Behavior__lastUploadedChoregrapheBehaviorbehavior_1892204656__root__GetSmile_5: Smile Properties: 47915 => [0.3400000035762787, 0.8450000286102295]

Es werden zwei in "[]" eingeschlossene Zahlen ausgegeben, z. B. "[0.3400000035762787, 0.8450000286102295]". Die erste ist der Lächelngrad und die zweite ist die Genauigkeit des Lächelngrads. Diese Genauigkeit ist ein numerischer Wert, der den Grad des Vertrauens in den eingestellten Wert für das Lächeln angibt. Je näher er an 0 liegt, desto weniger sicher ist er und je näher er an 1 liegt, desto sicherer ist er.

Auf diese Weise können unter Bezugnahme auf "PeoplePerception / Person / / SmileProperties" detailliertere Werte erhalten und eine Feinsteuerung durchgeführt werden.

Beurteilung anderer Gesichtsausdrücke als Lächeln

Das Erkennen und Formatieren von Lächeln ist unterschiedlich, aber wenn Sie die Werte "PeoplePerception / Person / / ExpressionProperties" verwenden, sind die Gesichtsausdrücke der Menschen neutral, glücklich, überrascht und wütend (überrascht). Es ist möglich festzustellen, ob es wütend oder traurig aussieht. Die von "SmileProperties" erhaltenen Informationen hatten die Form "[Lächeln, Genauigkeit]", aber der Wert von "ExpressionProperties" lag in der Reihenfolge "[Ausdruckslos, glücklich, überraschend, wütend, traurig]". Der Grad der Beurteilung als Ausdruck wird im Bereich von 0,0 bis 1,0 gespeichert. Außerdem wird die Summe dieser Werte auf 1,0 gesetzt.

Ein Beispiel mit diesem Wert wird als Beispielprojekt ** get-expression ** bereitgestellt. Von den von GitHub erhaltenen Dateien können Sie sie öffnen, indem Sie im Ordner "get-expression" auf "get-expression.pml" doppelklicken. Es wird wie folgt erstellt.

  1. Erstellen Sie ein Get Expression-Feld als leeres Python-Feld

    get-expression.png

Die an den onMax-Ausgang ausgegebenen Werte sind 0 ... neutral, 1 ... glücklich, 2 ... überrascht, 3 ... wütend, 4 ... traurig.

  1. Schreiben Sie den folgenden Code als Feld "Ausdruck abrufen"

    class MyClass(GeneratedClass):
        def __init__(self):
            GeneratedClass.__init__(self)
    
        def onLoad(self):
            self.memory = ALProxy("ALMemory")
            self.faceChar = ALProxy("ALFaceCharacteristics")
    
        def onUnload(self):
            pass
    
        def onInput_onPeopleDetected(self, peopleId):
            if peopleId < 0:
                return
            r = self.faceChar.analyzeFaceCharacteristics(peopleId)
            if not r:
                self.onUnknown()
                return
            exprData = self.memory.getData("PeoplePerception/Person/%d/ExpressionProperties" % peopleId)
            self.logger.info("Expression Properties: %d => %s" % (peopleId, exprData))
            if exprData and len(exprData) == 5:
                self.onNeutral(exprData[0])
                self.onHappy(exprData[1])
                self.onSurprised(exprData[2])
                self.onAngry(exprData[3])
                self.onSad(exprData[4])
                self.onMax(exprData.index(max(exprData)))
            else:
                self.onUnknown()
    
  2. Schreiben Sie zum Testen beispielsweise den folgenden Ablauf. Jede Ausgabe von onNeutral an onSad ändert den Inhalt des Protokollfelds, in dem das Protokoll zur Überprüfung des Vorgangs ausgegeben wird, z. B. "Sie sehen glücklich aus" oder "Sind Sie überrascht?". Platziere die Schachtel

    get-expression-example.png

Auf diese Weise können Sie jeden Wert von "ExpressionProperties" abrufen, entsprechend dem Element mit dem höchsten Wert sprechen und so weiter.

Wenn Sie beispielsweise ein Beispielprojekt ausführen, den Mund öffnen, die Augen öffnen und ein überraschtes Gesicht erstellen, wird das Protokoll wie folgt ausgegeben: Sie können sehen, dass der Artikel "Überrascht" einen großen Wert hat.

[INFO ] behavior.box :onInput_onPeopleDetected:20 _Behavior__...: Expression Properties: 60331 => [0.14000000059604645, 0.0, 0.85999995470047, 0.0, 0.0]
[INFO ] behavior.box :onInput_message:27 _Behavior__...: Neutral: 0.140000000596
[INFO ] behavior.box :onInput_message:27 _Behavior__...: Happy: 0.0
[INFO ] behavior.box :onInput_message:27 _Behavior__...: Surprised: 0.8599999547
[INFO ] behavior.box :onInput_message:27 _Behavior__...: Angry: 0.0
[INFO ] behavior.box :onInput_message:27 _Behavior__...: Sad: 0.0

Da der dritte Wert von "ExpressionProperties", der überraschende Wert, der Maximalwert ist, wird "2" in der onMax-Ausgabe ausgegeben. Dieser Wert wird in das Feld Switch Case eingegeben und der Vorgang "Sind Sie überrascht?" Wird ausgeführt.

Auf diese Weise ist es mit "PeoplePerception / Person / / ExpressionProperties" möglich, andere Gesichtsausdrücke als Lächeln zu beurteilen. Durch die Verwendung der Gesichtsinformationen wie Lächeln, die wir bisher gesehen haben, ist es möglich, Pepper entsprechend den Emotionen des Benutzers zu bewegen.

Recommended Posts

Gesichtserkennung mit Peppers API
Ich habe versucht, die Gesichtserkennungs-API von Microsoft für Cognitive Services zu verwenden
Expressionsnachweis mit Yolov5
Kategorieschätzung mit der Bilderkennungs-API von docomo
Extrahieren Sie Zeichen aus Bildern mithilfe der Zeichenerkennungs-API von docomo
Sprachdateierkennung durch Google Speech API v2 mit Python
Bilderkennung mit API aus null Wissen mit AutoML Vision
Testen Sie die CloudStack-API mit Simulator
Ich habe versucht, das Gesicht mit Face ++ zu erkennen
Versuchen Sie es mit der Twitter-API
Laden Sie Videos mit der YouTube-API hoch
Versuchen Sie es mit der Twitter-API
Führen Sie die handschriftliche Zeichenerkennung mit Pylearn 2 durch
Versuchen Sie es mit der PeeringDB 2.0-API
Verwenden Sie configparser, wenn Sie die API verwenden
Streamen Sie die Spracherkennung mithilfe der gRPC-API von Google Cloud Speech mit Python3 auf dem Mac!
Ich habe versucht, die Docomo-Spracherkennungs-API und die Google Speech-API in Java zu verwenden