HoloLens (1. Generation) und Azure 303: Natürliches Sprachverständnis (LUIS)


Hinweis

Die Tutorials der Mixed Reality Academy wurden im Hinblick auf HoloLens (1. Gen.) und immersive Mixed Reality-Headsets entworfen. Daher halten wir es für wichtig, diese Tutorials für Entwickler verfügbar zu halten, die noch nach Anleitung beim Entwickeln für diese Geräte suchen. Diese Tutorials werden nicht mit den neuesten Toolsets oder Interaktionen aktualisiert, die für HoloLens 2 verwendet werden. Sie werden gewartet, um weiterhin auf den unterstützten Geräten zu funktionieren. Es gibt eine neue Reihe von Lernprogrammen, die in Zukunft veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickeln. Diese Benachrichtigung wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.


In diesem Kurs erfahren Sie, wie Sie Language Understanding in eine Mixed Reality-Anwendung mit Azure Cognitive Services integrieren, mit der Language Understanding-API.

Lab outcome

Language Understanding (LUIS) ist ein Microsoft Azure-Dienst, der Anwendungen mit der Möglichkeit bietet, die Bedeutung von Benutzereingaben zu machen, z. B. durch extrahieren, was eine Person in ihren eigenen Worten wünschen könnte. Dies wird durch maschinelles Lernen erreicht, das die Eingabeinformationen versteht und lernt, und kann dann mit detaillierten, relevanten Informationen antworten. Weitere Informationen finden Sie auf der Seite Azure Language Understanding (LUIS).

Nachdem Sie diesen Kurs abgeschlossen haben, verfügen Sie über eine immersive Headset-Anwendung mit mixed Reality, die folgendes tun kann:

  1. Erfassen Sie Die Benutzereingabesprache mithilfe des Mikrofons, das an das immersive Headset angefügt ist.
  2. Senden Sie das erfasste Diktat des Azure Language Understanding Intelligent Service (LUIS).
  3. Haben Sie LUIS extrahieren Bedeutung aus den Senden-Informationen, die analysiert werden, und versuchen Sie, die Absicht der Anforderung des Benutzers zu ermitteln.

Die Entwicklung umfasst die Erstellung einer App, in der der Benutzer Die Stimme und/oder den Blick verwenden kann, um die Größe und die Farbe der Objekte in der Szene zu ändern. Die Verwendung von Bewegungscontrollern wird nicht behandelt.

In Ihrer Anwendung ist es Ihnen bis hin zur Integration der Ergebnisse in Ihr Design erforderlich. Dieser Kurs ist konzipiert, um Ihnen zu vermitteln, wie Sie einen Azure Service mit Ihrem Unity-Project integrieren. Es ist Ihr Auftrag, das Wissen zu verwenden, das Sie von diesem Kurs erhalten, um Ihre Mixed Reality-Anwendung zu verbessern.

Werden Sie mehrmals bereit, LUIS zu trainieren, der in Kapitel 12 behandelt wird. Sie erhalten bessere Ergebnisse, wenn LUIS trainiert wurde.

Geräteunterstützung

Kurs HoloLens Immersive Headsets
MR und Azure 303: Natürliches Sprachverständnis (LUIS) ✔️ ✔️

Hinweis

Während sich dieser Kurs hauptsächlich auf Windows Mixed Reality immersiven (VR)-Headsets konzentriert, können Sie auch das anwenden, was Sie in diesem Kurs lernen, um Microsoft HoloLens. Während Sie mit dem Kurs folgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise zum Unterstützen von HoloLens verwenden müssen. Wenn Sie HoloLens verwenden, können Sie während der Sprachaufnahme einige Echos feststellen.

Voraussetzungen

Hinweis

Dieses Lernprogramm ist für Entwickler konzipiert, die grundlegende Erfahrungen mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen innerhalb dieses Dokuments das testen und überprüft haben, was zum Zeitpunkt des Schreibens (Mai 2018) überprüft wurde. Sie sind kostenlos, die neueste Software zu verwenden, wie im Installationsartikel der Tools aufgeführt, aber es sollte nicht angenommen werden, dass die Informationen in diesem Kurs perfekt mit dem übereinstimmen, was Sie in neuerer Software finden, als was unten aufgeführt ist.

Wir empfehlen die folgende Hardware und Software für diesen Kurs:

Vorbereitung

  1. Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, dass Sie das Projekt erstellen, das in diesem Lernprogramm in einem Stamm- oder In-Stammordner erwähnt wird (lange Ordnerpfade können probleme beim Buildvorgang verursachen).

  2. Um Ihrem Computer die Aktivierung von Diktieren zu ermöglichen, wechseln Sie zu Windows Einstellungen > Datenschutzsprache>, Freihandeingabe & und drücken Sie auf die Schaltfläche "Sprachdienste aktivieren" und geben Sie Vorschläge ein.

  3. Mit dem Code in diesem Lernprogramm können Sie auf Ihrem Computer das Standard mikrofongerät aufzeichnen. Stellen Sie sicher, dass das Standardmäßige Mikrofongerät als der festgelegt ist, den Sie verwenden möchten, um Ihre Stimme zu erfassen.

  4. Wenn Ihr Headset über ein integriertes Mikrofon verfügt, stellen Sie sicher, dass die Option "Wenn ich mein Headset trägt, auf Headset-Mikrofon wechseln" in den Mixed Reality Portaleinstellungen aktiviert ist.

    Setting up immersive headset

Kapitel 1 – Einrichten des Azure-Portals

Um den Language Understanding-Dienst in Azure zu verwenden, müssen Sie eine Instanz des Diensts konfigurieren, der für Ihre Anwendung verfügbar gemacht werden soll.

  1. Melden Sie sich beim Azure-Portal an.

    Hinweis

    Wenn Sie noch kein Azure-Konto haben, müssen Sie eine erstellen. Wenn Sie diesem Lernprogramm in einer Klassenzimmer- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Proctors, um Hilfe beim Einrichten Ihres neuen Kontos zu erhalten.

  2. Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Neu", und suchen Sie nach Language Understanding, und klicken Sie auf "Eingabetaste".

    Create LUIS resource

    Hinweis

    Das Wort "Neu" wurde möglicherweise durch "Erstellen einer Ressource" in neueren Portalen ersetzt.

  3. Die neue Seite rechts enthält eine Beschreibung des Language Understanding-Diensts. Wählen Sie unten links auf dieser Seite die Schaltfläche "Erstellen " aus, um eine Instanz dieses Diensts zu erstellen.

    LUIS service creation - legal notice

  4. Nachdem Sie auf "Erstellen" geklickt haben:

    1. Fügen Sie Ihren gewünschten Namen für diese Dienstinstanz ein.

    2. Wählen Sie ein Abonnementaus.

    3. Wählen Sie die für Sie geeignete Preisstufe aus, wenn dies zum ersten Mal das Erstellen eines LUIS-Diensts ist, sollte eine kostenlose Stufe (benannt F0) für Sie verfügbar sein. Die kostenlose Zuweisung sollte für diesen Kurs mehr als ausreichend sein.

    4. Wählen Sie eine Ressourcengruppe aus, oder erstellen Sie eine neue. Eine Ressourcengruppe bietet eine Möglichkeit zum Überwachen, Steuern des Zugriffs, Bereitstellen und Verwalten der Abrechnung für eine Sammlung von Azure-Ressourcen. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt zugeordnet sind (z. B. diese Kurse), unter einer gemeinsamen Ressourcengruppe beizubehalten.

      Wenn Sie mehr über Azure-Ressourcengruppen lesen möchten, besuchen Sie den Ressourcengruppenartikel.

    5. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Standort wäre idealerweise in der Region, in der die Anwendung ausgeführt wird. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.

    6. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Bedingungen verstanden haben.

    7. Klicken Sie auf Erstellen.

      Create LUIS service - user input

  5. Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt werden soll, dies kann eine Minute dauern.

  6. Eine Benachrichtigung wird im Portal angezeigt, sobald die Dienstinstanz erstellt wird.

    New Azure notification image

  7. Klicken Sie auf die Benachrichtigung, um Ihre neue Dienstinstanz zu erkunden.

    Successful resource creation notification

  8. Klicken Sie in der Benachrichtigung auf die Schaltfläche " Zu Ressourcen wechseln ", um Ihre neue Dienstinstanz zu erkunden. Sie werden zur neuen LUIS-Dienstinstanz weitergeleitet.

    Accessing LUIS Keys

  9. Innerhalb dieses Lernprogramms müssen Ihre Anwendung Anrufe an Ihren Dienst vornehmen, die über den Abonnementschlüssel Ihres Diensts ausgeführt wird.

  10. Navigieren Sie auf der Schnellstartseite Ihres LUIS-API-Diensts zum ersten Schritt, navigieren Sie zu Den Schlüsseln, und klicken Sie auf "Schlüssel" (Sie können dies auch erreichen, indem Sie auf die blauen Hyperlinktasten klicken, die im Navigationsmenü der Dienste angezeigt werden, das durch das Tastensymbol gekennzeichnet ist). Dadurch werden Ihre Dienstschlüssel angezeigt.

  11. Nehmen Sie eine Kopie eines der angezeigten Schlüssel ab, da Sie dies später in Ihrem Projekt benötigen.

  12. Klicken Sie auf der Seite "Dienst" auf Language Understanding Portal, um zur Webseite umgeleitet zu werden, die Sie zum Erstellen Ihres neuen Diensts in der LUIS-App verwenden.

Kapitel 2 – Das Language Understanding Portal

In diesem Abschnitt erfahren Sie, wie Sie eine LUIS-App im LUIS-Portal erstellen.

Wichtig

Bitte beachten Sie, dass das Einrichten der Entitäten, Absichten und Utterancen innerhalb dieses Kapitels nur der erste Schritt beim Erstellen Ihres LUIS-Diensts ist: Sie müssen den Dienst auch mehrmals neu trainieren, damit es genauer wird. Die Umschulung Ihres Dienstes wird im letzten Kapitel dieses Kurses behandelt, sodass Sie sicherstellen, dass Sie ihn abschließen.

  1. Wenn Sie das Language Understanding Portal erreichen, müssen Sie sich möglicherweise anmelden, wenn Sie noch nicht sind, mit den gleichen Anmeldeinformationen wie Ihre Azure-Portal.

    LUIS login page

  2. Wenn Sie luis zum ersten Mal verwenden, müssen Sie nach unten auf der Willkommensseite scrollen, um die Schaltfläche "LUIS-App erstellen " zu finden und darauf zu klicken.

    Create LUIS app page

  3. Klicken Sie nach der Anmeldung auf "Meine Apps " (wenn Sie sich derzeit nicht in diesem Abschnitt befinden). Sie können dann auf "Neue App erstellen" klicken.

    LUIS - my apps image

  4. Geben Sie der App einen Namen.

  5. Wenn Ihre App eine andere Sprache als Englisch verstehen soll, sollten Sie die Kultur in die entsprechende Sprache ändern.

  6. Hier können Sie auch eine Beschreibung Ihrer neuen LUIS-App hinzufügen.

    LUIS - create a new app

  7. Sobald Sie fertig sind, geben Sie die Buildseite Ihrer neuen LUIS-Anwendung ein.

  8. Hier sind einige wichtige Konzepte zu verstehen:

    • Intent stellt die Methode dar, die nach einer Abfrage vom Benutzer aufgerufen wird. Eine ABSICHT verfügt möglicherweise über eine oder mehrere ENTITÄTen.
    • Entität ist eine Komponente der Abfrage, die Informationen beschreibt, die für die ABSICHT relevant sind.
    • Utterances, sind Beispiele für Abfragen, die vom Entwickler bereitgestellt werden, dass LUIS verwendet wird, um sich selbst zu trainieren.

Wenn diese Konzepte nicht perfekt klar sind, machen Sie sich keine Sorgen, da dieser Kurs sie weiter in diesem Kapitel klären wird.

Sie beginnen mit dem Erstellen der Entitäten , die zum Erstellen dieses Kurses erforderlich sind.

  1. Klicken Sie auf der linken Seite der Seite auf Entitäten, und klicken Sie dann auf "Neue Entität erstellen".

    Create new entity

  2. Rufen Sie die neue Entitätsfarbe auf", legen Sie den Typ auf "Einfach" fest, und drücken Sie dann "Fertig".

    Create simple entity - color

  3. Wiederholen Sie diesen Vorgang, um drei (3) einfachere Entitäten zu erstellen:

    • Upsizing
    • Verkleinern
    • Ziel

Das Ergebnis sollte wie folgt aussehen:

Result of entity creation

An diesem Punkt können Sie mit der Erstellung von Absichten beginnen.

Warnung

Löschen Sie nicht die Absicht "Keine ".

  1. Klicken Sie auf der linken Seite der Seite auf "Absichten", und klicken Sie dann auf "Neue Absicht erstellen".

    Create new intents

  2. Rufen Sie die neue IntentChangeObjectColor auf.

    Wichtig

    Dieser Absichtsname wird später in diesem Kurs innerhalb des Codes verwendet, damit die besten Ergebnisse erzielt werden, verwenden Sie diesen Namen genau wie angegeben.

Sobald Sie den Namen bestätigen, werden Sie zur Seite "Absichten" weitergeleitet.

LUIS - intents page

Sie werden feststellen, dass es ein Textfeld gibt, in dem Sie aufgefordert werden, 5 oder mehr verschiedene Utterances einzugeben.

Hinweis

LUIS konvertiert alle Utterances in Kleinschreibung.

  1. Fügen Sie die folgende Utterance in das obere Textfeld ein (derzeit mit dem Texttyp etwa 5 Beispiele... ), und drücken Sie die EINGABETASTE:
The color of the cylinder must be red

Sie werden feststellen, dass die neue Utterance in einer Liste darunter angezeigt wird.

Fügen Sie nach demselben Prozess die folgenden sechs (6) Utterances ein:

make the cube black

make the cylinder color white

change the sphere to red

change it to green

make this yellow

change the color of this object to blue

Für jede von Ihnen erstellte Utterance müssen Sie ermitteln, welche Wörter von LUIS als Entitäten verwendet werden sollen. In diesem Beispiel müssen Sie alle Farben als Farbentität bezeichnen, und alle möglichen Verweise auf ein Ziel als Zielentität.

  1. Klicken Sie dazu im ersten Utterance auf den Wortzylinder , und wählen Sie das Ziel aus.

    Identify Utterance Targets

  2. Klicken Sie nun in der ersten Utterance auf das Wort Rot , und wählen Sie die Farbe aus.

    Identify Utterance Entities

  3. Beschriften Sie auch die nächste Zeile, wobei Würfel ein Ziel sein soll, und schwarz sollte eine Farbe sein. Beachten Sie auch die Verwendung der Wörter "this", "it" und "this object", die wir bereitstellen, damit auch nicht spezifische Zieltypen verfügbar sind.

  4. Wiederholen Sie den obigen Vorgang, bis alle Utterances die Entitäten gekennzeichnet haben. Sehen Sie sich das folgende Bild an, wenn Sie Hilfe benötigen.

    Tipp

    Wenn Sie Wörter auswählen, um sie als Entitäten zu beschriften, gelten folgende Regeln:

    • Klicken Sie für einzelne Wörter einfach darauf.
    • Klicken Sie für einen Satz von zwei oder mehr Wörtern am Anfang und dann am Ende des Satzes.

    Hinweis

    Sie können die Schaltfläche "Tokenansicht" verwenden, um zwischen Entitäten / Tokenansicht zu wechseln!

  5. Die Ergebnisse sollten in den folgenden Bildern mit der Ansicht Entitäten / Token angezeigt werden:

    Tokens & Entities Views

  6. Drücken Sie an diesem Punkt die Schaltfläche "Train" oben rechts auf der Seite, und warten Sie, bis die kleine runde Anzeige darauf wartet, dass sie grün wird. Dies gibt an, dass LUIS erfolgreich geschult wurde, um diese Absicht zu erkennen.

    Train LUIS

  7. Erstellen Sie als Übung für Sie eine neue Absicht namens ChangeObjectSize mit dem Ziel "Entitäten", "Upsize" und "Downsize".

  8. Fügen Sie nach demselben Prozess wie die vorherige Absicht die folgenden acht (8) Utterances für die Größenänderung ein:

    increase the dimensions of that
    
    reduce the size of this
    
    i want the sphere smaller
    
    make the cylinder bigger
    
    size down the sphere
    
    size up the cube
    
    decrease the size of that object
    
    increase the size of this object
    
  9. Das Ergebnis sollte wie die in der Abbildung unten dargestellte sein:

    Setup the ChangeObjectSize Tokens/ Entities

  10. Nachdem beide Intents, ChangeObjectColor und ChangeObjectSize, erstellt und trainiert wurden, klicken Sie oben auf der Seite auf die Schaltfläche "VERÖFFENTLICHEN ".

    Publish LUIS service

  11. Auf der Veröffentlichungsseite werden Sie Ihre LUIS-App abschließen und veröffentlichen, damit sie von Ihrem Code aufgerufen werden kann.

    1. Legen Sie die Dropdownliste "Veröffentlichen alsProduktion" fest.

    2. Legen Sie die Zeitzone auf Ihre Zeitzone fest.

    3. Aktivieren Sie das Kontrollkästchen "Alle vorhergesagten Absichtsergebnisse einschließen".

    4. Klicken Sie auf "In Produktionsplatz veröffentlichen".

      Publish Settings

  12. Im Abschnitt Ressourcen und Schlüssel:

    1. Wählen Sie die Region aus, die Sie für Dienstinstanzen im Azure-Portal festgelegt haben.
    2. Sie werden ein Starter_Key Element unten sehen, ignorieren Sie es.
    3. Klicken Sie auf "Schlüssel hinzufügen ", und fügen Sie den Schlüssel ein, den Sie beim Erstellen Ihrer Dienstinstanz im Azure-Portal erhalten haben. Wenn Ihr Azure- und das LUIS-Portal mit demselben Benutzer angemeldet sind, erhalten Sie Dropdownmenüs für Mandantennamen, Abonnementname und den Schlüssel , den Sie verwenden möchten (wird denselben Namen wie zuvor im Azure-Portal angegeben haben.

    Wichtig

    Nehmen Sie unterhalb des Endpunkts eine Kopie des Endpunkts, der dem von Ihnen eingefügten Schlüssel entspricht, in Kürze in Ihrem Code.

Kapitel 3 – Einrichten des Unity-Projekts

Nachfolgend sehen Sie eine typische Einrichtung für die Entwicklung mit der Mixed Reality und ist daher eine gute Vorlage für andere Projekte.

  1. Öffnen Sie Unity , und klicken Sie auf "Neu".

    Start new Unity project.

  2. Sie müssen jetzt einen Unity-Project Namen angeben, MR_LUIS einfügen. Stellen Sie sicher, dass der Projekttyp auf 3D festgelegt ist. Legen Sie den Speicherort an einer beliebigen Stelle fest, die für Sie geeignet ist (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".

    Provide details for new Unity project.

  3. Wenn Unity geöffnet ist, empfiehlt es sich, den Standardskript-Editor auf Visual Studio festzulegen. Wechseln Sie zu "Einstellungen bearbeiten" > , und navigieren Sie dann im neuen Fenster zu "Externe Tools". Ändern Sie den externen Skript-Editor in Visual Studio 2017. Schließen Sie das Fenster "Einstellungen" .

    Update script editor preference.

  4. Wechseln Sie als Nächstes zu "Dateibuild > Einstellungen", und wechseln Sie zu Universelle Windows-Plattform, indem Sie auf die Schaltfläche "Plattform wechseln" klicken.

    Build Settings window, switch platform to UWP.

  5. Wechseln Sie zu "Dateibuild > Einstellungen", und stellen Sie sicher, dass:

    1. Zielgerät ist auf "Beliebiges Gerät" festgelegt.

      Legen Sie für die Microsoft HoloLens das Zielgerätauf HoloLens fest.

    2. Buildtyp ist auf D3D festgelegt

    3. SDK ist auf "Neueste Installation" festgelegt.

    4. Visual Studio Version ist auf "Neueste Installation" festgelegt.

    5. Build und Run ist auf lokalen Computer festgelegt

    6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.

      1. Wählen Sie dazu "Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.

        Click add open scenes button

      2. Erstellen Sie einen neuen Ordner für diesen Ordner und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, benennen Sie ihn "Szenen".

        Create new scripts folder

      3. Öffnen Sie ihren neu erstellten Szenenordner , und drücken Sie dann im Feld "Dateiname: Textfeld", MR_LuisScene eingeben und dann "Speichern" drücken.

        Give new scene a name.

    7. Die verbleibenden Einstellungen in Build Einstellungen sollten jetzt als Standard beibehalten werden.

  6. Klicken Sie im Fenster "Build Einstellungen" auf die Schaltfläche "Player Einstellungen". Dadurch wird der zugehörige Bereich im Bereich geöffnet, in dem sich der Inspektor befindet.

    Open player settings.

  7. In diesem Bereich müssen einige Einstellungen überprüft werden:

    1. Auf der Registerkarte "Andere Einstellungen":

      1. Skriptlaufzeitversion sollte stabil sein (.NET 3.5 Äquivalent).

      2. Skript-Back-End sollte .NET sein

      3. API-Kompatibilitätsebene sollte .NET 4.6 sein

        Update other settings.

    2. Überprüfen Sie auf der Registerkarte "Veröffentlichen Einstellungen" unter "Funktionen":

      1. InternetClient

      2. Mikrofon

        Updating publishing settings.

    3. Klicken Sie weiter unten im Bereich in XR Einstellungen (unter "Veröffentlichen Einstellungen") auf "Virtual Reality Unterstützt", stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wird.

      Update the X R Settings.

  8. Zurück in Build EinstellungenUnity C#-Projekte ist nicht mehr abgeblentet. Aktivieren Sie das Kontrollkästchen neben diesem.

  9. Schließen Sie das Fenster „Build Settings“ (Buildeinstellungen).

  10. Speichern Sie Ihre Szene und Project (FILE SAVE SCENE / FILE >> SAVE PROJECT).

Kapitel 4 – Erstellen der Szene

Wichtig

Wenn Sie die Unity Setup-Komponente dieses Kurses überspringen und direkt in Code fortfahren möchten, können Sie dieses Unitypackage herunterladen, es in Ihr Projekt als benutzerdefiniertes Paket importieren und dann von Kapitel 5 fortfahren.

  1. Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs unter 3D-Objekt, fügen Sie eine Ebene hinzu.

    Create a plane.

  2. Beachten Sie, dass beim erneuten Klicken mit der rechten Maustaste in der Hierarchie , um weitere Objekte zu erstellen, wenn das letzte Objekt noch ausgewählt ist, das ausgewählte Objekt das übergeordnete Objekt des neuen Objekts ist. Vermeiden Sie dieses Linksklick in einem leeren Leerzeichen innerhalb der Hierarchie, und klicken Sie dann mit der rechten Maustaste.

  3. Wiederholen Sie die obige Prozedur, um die folgenden Objekte hinzuzufügen:

    1. Sphere
    2. Zylinder
    3. Cube
    4. 3D-Text
  4. Die resultierende Szenenhierarchie sollte wie die in der Abbildung unten dargestellte sein:

    Scene Hierarchy setup.

  5. Klicken Sie links auf die Hauptkamera , um sie auszuwählen, sehen Sie sich den Inspektorbereich an, das Kameraobjekt mit allen komponenten angezeigt wird.

  6. Klicken Sie unten im Inspektorbereich auf die Schaltfläche "Komponente hinzufügen".

    Add Audio Source

  7. Suchen Sie nach der Komponente namens "Audioquelle", wie oben gezeigt.

  8. Stellen Sie außerdem sicher, dass die Transformationskomponente der Hauptkamera auf (0,0,0) festgelegt ist, dies kann erfolgen, indem Sie das Zahnradsymbol neben der Transformationskomponente der Kamera drücken und zurücksetzen auswählen. Die Transformationskomponente sollte dann wie folgt aussehen:

    1. Die Position ist auf 0, 0, 0 festgelegt.
    2. Drehung ist auf 0, 0, 0 festgelegt.

    Hinweis

    Für die Microsoft HoloLens müssen Sie auch folgendes ändern, was Teil der Kamerakomponente ist, die sich auf Ihrer Hauptkamera befindet:

    • Flags löschen: Volltonfarbe.
    • Hintergrund "Schwarz, Alpha 0" – Hexfarbe: #0000000000.
  9. Klicken Sie links auf die Ebene , um sie auszuwählen. Legen Sie im Inspektorbereich die Transformationskomponente mit den folgenden Werten fest:

    X-Achse Y-Achse Z-Achse
    0 -1 0
  10. Klicken Sie links auf die Kugel , um sie auszuwählen. Legen Sie im Inspektorbereich die Transformationskomponente mit den folgenden Werten fest:

    X-Achse Y-Achse Z-Achse
    2 1 2
  11. Klicken Sie links auf den Zylinder , um ihn auszuwählen. Legen Sie im Inspektorbereich die Transformationskomponente mit den folgenden Werten fest:

    X-Achse Y-Achse Z-Achse
    -2 1 2
  12. Klicken Sie links auf den Cube , um ihn auszuwählen. Legen Sie im Inspektorbereich die Transformationskomponente mit den folgenden Werten fest:

    Transformieren – Position | Transformation - Drehung
    X J Z | X J Z
    0 1 4 | 45 45 0
  13. Klicken Sie links auf das Neue Text-Objekt , um es auszuwählen. Legen Sie im Inspektorbereich die Transformationskomponente mit den folgenden Werten fest:

    Transformieren – Position | Transformation – Skalierung
    X J Z | X J Z
    -2 6 9 | 0,1 0,1 0,1
  14. Ändern Des Schriftgrads in der Komponente "Text" Mesh in 50.

  15. Ändern Sie den Namen des Text-Mesh-Objekts in "Diktiertext".

    Create 3D Text object

  16. Die Struktur des Hierarchiebereichs sollte nun wie folgt aussehen:

    text mesh in scene view

  17. Die letzte Szene sollte wie das folgende Bild aussehen:

    The scene view.

Kapitel 5 – Erstellen der MikrofonManager-Klasse

Das erste Skript, das Sie erstellen möchten, ist die MikrofonManager-Klasse . Danach erstellen Sie den LuisManager, die Behaviors-Klasse und schließlich die Gaze-Klasse (fühlen Sie sich frei, all diese jetzt zu erstellen, obwohl sie beim Erreichen der einzelnen Kapitel abgedeckt werden).

Die MikrofonManager-Klasse ist verantwortlich für:

  • Erkennen des Aufzeichnungsgeräts, das an das Headset oder den Computer angeschlossen ist (je nachdem, was die Standardeinstellung ist).
  • Erfassen Sie die Audiodaten (Stimme), und verwenden Sie diktieren, um sie als Zeichenfolge zu speichern.
  • Nachdem die Stimme angehalten wurde, übermitteln Sie das Diktieren an die LuisManager-Klasse .

So erstellen Sie diese Klasse:

  1. Klicken Sie mit der rechten Maustaste im bereich "Project Bereich", "Ordner erstellen">. Rufen Sie die Ordnerskripts auf.

    Create Scripts folder.

  2. Wenn der Ordner "Skripts " erstellt wurde, doppelklicken Sie darauf, um ihn zu öffnen. Klicken Sie dann in diesem Ordner mit der rechten Maustaste auf "C#-Skript erstellen>". Nennen Sie das Skript "MicrophoneManager".

  3. Doppelklicken Sie auf "MicrophoneManager", um ihn mit Visual Studio zu öffnen.

  4. Fügen Sie oben in der Datei die folgenden Namespaces hinzu:

        using UnityEngine;
        using UnityEngine.Windows.Speech;
    
  5. Fügen Sie dann die folgenden Variablen innerhalb der MikrofonManager-Klasse hinzu:

        public static MicrophoneManager instance; //help to access instance of this object
        private DictationRecognizer dictationRecognizer;  //Component converting speech to text
        public TextMesh dictationText; //a UI object used to debug dictation result
    
  6. Code für Awake() und Start() -Methoden müssen jetzt hinzugefügt werden. Dies wird aufgerufen, wenn die Klasse initialisiert wird:

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
        void Start()
        {
            if (Microphone.devices.Length > 0)
            {
                StartCapturingAudio();
                Debug.Log("Mic Detected");
            }
        }
    
  7. Jetzt benötigen Sie die Methode, die die App zum Starten und Beenden der Sprachaufnahme verwendet, und übergeben Sie sie an die LuisManager-Klasse , die Sie bald erstellen werden.

        /// <summary>
        /// Start microphone capture, by providing the microphone as a continual audio source (looping),
        /// then initialise the DictationRecognizer, which will capture spoken words
        /// </summary>
        public void StartCapturingAudio()
        {
            if (dictationRecognizer == null)
            {
                dictationRecognizer = new DictationRecognizer
                {
                    InitialSilenceTimeoutSeconds = 60,
                    AutoSilenceTimeoutSeconds = 5
                };
    
                dictationRecognizer.DictationResult += DictationRecognizer_DictationResult;
                dictationRecognizer.DictationError += DictationRecognizer_DictationError;
            }
            dictationRecognizer.Start();
            Debug.Log("Capturing Audio...");
        }
    
        /// <summary>
        /// Stop microphone capture
        /// </summary>
        public void StopCapturingAudio()
        {
            dictationRecognizer.Stop();
            Debug.Log("Stop Capturing Audio...");
        }
    
  8. Fügen Sie einen Diktierhandler hinzu, der aufgerufen wird, wenn die Stimme angehalten wird. Mit dieser Methode wird der Diktiertext an die LuisManager-Klasse übergeben.

        /// <summary>
        /// This handler is called every time the Dictation detects a pause in the speech. 
        /// This method will stop listening for audio, send a request to the LUIS service 
        /// and then start listening again.
        /// </summary>
        private void DictationRecognizer_DictationResult(string dictationCaptured, ConfidenceLevel confidence)
        {
            StopCapturingAudio();
            StartCoroutine(LuisManager.instance.SubmitRequestToLuis(dictationCaptured, StartCapturingAudio));
            Debug.Log("Dictation: " + dictationCaptured);
            dictationText.text = dictationCaptured;
        }
    
        private void DictationRecognizer_DictationError(string error, int hresult)
        {
            Debug.Log("Dictation exception: " + error);
        }
    

    Wichtig

    Löschen Sie die Update()- Methode, da diese Klasse sie nicht verwendet.

  9. Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

    Hinweis

    An diesem Punkt wird ein Fehler im Unity Editor Console Panel angezeigt. Dies liegt daran, dass der Code auf die LuisManager-Klasse verweist, die Sie im nächsten Kapitel erstellen.

Kapitel 6 – Erstellen der LUISManager-Klasse

Es ist an der Zeit, die LuisManager-Klasse zu erstellen, die den Aufruf an den Azure LUIS-Dienst macht.

Der Zweck dieser Klasse besteht darin, den Diktiertext aus der MikrofonManager-Klasse zu empfangen und an die Azure Language Understanding-API zu senden, die analysiert werden soll.

Diese Klasse wird die JSON-Antwort deserialisieren und die entsprechenden Methoden der Behaviors-Klasse aufrufen, um eine Aktion auszulösen.

So erstellen Sie diese Klasse:

  1. Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.

  2. Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript LuisManager.

  3. Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

  4. Fügen Sie oben in der Datei die folgenden Namespaces hinzu:

        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. Sie erstellen zunächst drei Klassen innerhalb der LuisManager-Klasse (innerhalb derselben Skriptdatei, oberhalb der Start() -Methode, die die deserialisierte JSON-Antwort von Azure darstellt.

        [Serializable] //this class represents the LUIS response
        public class AnalysedQuery
        {
            public TopScoringIntentData topScoringIntent;
            public EntityData[] entities;
            public string query;
        }
    
        // This class contains the Intent LUIS determines 
        // to be the most likely
        [Serializable]
        public class TopScoringIntentData
        {
            public string intent;
            public float score;
        }
    
        // This class contains data for an Entity
        [Serializable]
        public class EntityData
        {
            public string entity;
            public string type;
            public int startIndex;
            public int endIndex;
            public float score;
        }
    
  6. Fügen Sie als Nächstes die folgenden Variablen in der LuisManager-Klasse hinzu:

        public static LuisManager instance;
    
        //Substitute the value of luis Endpoint with your own End Point
        string luisEndpoint = "https://westus.api.cognitive... add your endpoint from the Luis Portal";
    
  7. Stellen Sie sicher, dass Sie ihren LUIS-Endpunkt jetzt platzieren (über das Sie über Ihr LUIS-Portal verfügen).

  8. Code für die Awake()- Methode muss jetzt hinzugefügt werden. Diese Methode wird aufgerufen, wenn die Klasse initialisiert wird:

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  9. Jetzt benötigen Sie die Methoden, die diese Anwendung verwendet, um das Diktier, das von der MikrofonManager-Klasse empfangen wurde, an LUIS zu senden und dann die Antwort zu empfangen und zu deserialisieren.

  10. Sobald der Wert der Absicht und zugeordneter Entitäten bestimmt wurde, werden sie an die Instanz der Behaviors-Klasse übergeben, um die beabsichtigte Aktion auszulösen.

        /// <summary>
        /// Call LUIS to submit a dictation result.
        /// The done Action is called at the completion of the method.
        /// </summary>
        public IEnumerator SubmitRequestToLuis(string dictationResult, Action done)
        {
            string queryString = string.Concat(Uri.EscapeDataString(dictationResult));
    
            using (UnityWebRequest unityWebRequest = UnityWebRequest.Get(luisEndpoint + queryString))
            {
                yield return unityWebRequest.SendWebRequest();
    
                if (unityWebRequest.isNetworkError || unityWebRequest.isHttpError)
                {
                    Debug.Log(unityWebRequest.error);
                }
                else
                {
                    try
                    {
                        AnalysedQuery analysedQuery = JsonUtility.FromJson<AnalysedQuery>(unityWebRequest.downloadHandler.text);
    
                        //analyse the elements of the response 
                        AnalyseResponseElements(analysedQuery);
                    }
                    catch (Exception exception)
                    {
                        Debug.Log("Luis Request Exception Message: " + exception.Message);
                    }
                }
    
                done();
                yield return null;
            }
        }
    
  11. Erstellen Sie eine neue Methode namens "AnalyseResponseElements(), die die resultierende AnalyseQuery liest und die Entitäten bestimmt. Sobald diese Entitäten bestimmt sind, werden sie an die Instanz der Behaviors-Klasse übergeben, die in den Aktionen verwendet werden soll.

        private void AnalyseResponseElements(AnalysedQuery aQuery)
        {
            string topIntent = aQuery.topScoringIntent.intent;
    
            // Create a dictionary of entities associated with their type
            Dictionary<string, string> entityDic = new Dictionary<string, string>();
    
            foreach (EntityData ed in aQuery.entities)
            {
                entityDic.Add(ed.type, ed.entity);
            }
    
            // Depending on the topmost recognized intent, read the entities name
            switch (aQuery.topScoringIntent.intent)
            {
                case "ChangeObjectColor":
                    string targetForColor = null;
                    string color = null;
    
                    foreach (var pair in entityDic)
                    {
                        if (pair.Key == "target")
                        {
                            targetForColor = pair.Value;
                        }
                        else if (pair.Key == "color")
                        {
                            color = pair.Value;
                        }
                    }
    
                    Behaviours.instance.ChangeTargetColor(targetForColor, color);
                    break;
    
                case "ChangeObjectSize":
                    string targetForSize = null;
                    foreach (var pair in entityDic)
                    {
                        if (pair.Key == "target")
                        {
                            targetForSize = pair.Value;
                        }
                    }
    
                    if (entityDic.ContainsKey("upsize") == true)
                    {
                        Behaviours.instance.UpSizeTarget(targetForSize);
                    }
                    else if (entityDic.ContainsKey("downsize") == true)
                    {
                        Behaviours.instance.DownSizeTarget(targetForSize);
                    }
                    break;
            }
        }
    

    Wichtig

    Löschen Sie die Methoden Start() und Update(), da diese Klasse sie nicht verwendet.

  12. Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Hinweis

An diesem Punkt werden mehrere Fehler im Unity Editor Console Panel angezeigt. Dies liegt daran, dass der Code auf die Verhaltensklasse verweist, die Sie im nächsten Kapitel erstellen.

Kapitel 7 – Erstellen der Verhaltensklasse

Die Behaviors-Klasse löst die Aktionen mithilfe der Entitäten aus, die von der LuisManager-Klasse bereitgestellt werden.

So erstellen Sie diese Klasse:

  1. Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.

  2. Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Benennen Sie das Skriptverhalten.

  3. Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

  4. Fügen Sie dann die folgenden Variablen innerhalb der Behaviors-Klasse hinzu:

        public static Behaviours instance;
    
        // the following variables are references to possible targets
        public GameObject sphere;
        public GameObject cylinder;
        public GameObject cube;
        internal GameObject gazedTarget;
    
  5. Fügen Sie den Code der Awake()- Methode hinzu. Diese Methode wird aufgerufen, wenn die Klasse initialisiert wird:

        void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  6. Die folgenden Methoden werden von der LuisManager-Klasse (die Sie zuvor erstellt haben) aufgerufen, um zu bestimmen, welches Objekt das Ziel der Abfrage ist und dann die entsprechende Aktion auslöst.

        /// <summary>
        /// Changes the color of the target GameObject by providing the name of the object
        /// and the name of the color
        /// </summary>
        public void ChangeTargetColor(string targetName, string colorName)
        {
            GameObject foundTarget = FindTarget(targetName);
            if (foundTarget != null)
            {
                Debug.Log("Changing color " + colorName + " to target: " + foundTarget.name);
    
                switch (colorName)
                {
                    case "blue":
                        foundTarget.GetComponent<Renderer>().material.color = Color.blue;
                        break;
    
                    case "red":
                        foundTarget.GetComponent<Renderer>().material.color = Color.red;
                        break;
    
                    case "yellow":
                        foundTarget.GetComponent<Renderer>().material.color = Color.yellow;
                        break;
    
                    case "green":
                        foundTarget.GetComponent<Renderer>().material.color = Color.green;
                        break;
    
                    case "white":
                        foundTarget.GetComponent<Renderer>().material.color = Color.white;
                        break;
    
                    case "black":
                        foundTarget.GetComponent<Renderer>().material.color = Color.black;
                        break;
                }          
            }
        }
    
        /// <summary>
        /// Reduces the size of the target GameObject by providing its name
        /// </summary>
        public void DownSizeTarget(string targetName)
        {
            GameObject foundTarget = FindTarget(targetName);
            foundTarget.transform.localScale -= new Vector3(0.5F, 0.5F, 0.5F);
        }
    
        /// <summary>
        /// Increases the size of the target GameObject by providing its name
        /// </summary>
        public void UpSizeTarget(string targetName)
        {
            GameObject foundTarget = FindTarget(targetName);
            foundTarget.transform.localScale += new Vector3(0.5F, 0.5F, 0.5F);
        }
    
  7. Fügen Sie die FindTarget() -Methode hinzu, um zu bestimmen, welche der GameObjects das Ziel der aktuellen Absicht ist. Bei dieser Methode wird standardmäßig das Ziel auf das GameObject festgelegt, das "gazed" ist, wenn kein explizites Ziel in den Entitäten definiert ist.

        /// <summary>
        /// Determines which object reference is the target GameObject by providing its name
        /// </summary>
        private GameObject FindTarget(string name)
        {
            GameObject targetAsGO = null;
    
            switch (name)
            {
                case "sphere":
                    targetAsGO = sphere;
                    break;
    
                case "cylinder":
                    targetAsGO = cylinder;
                    break;
    
                case "cube":
                    targetAsGO = cube;
                    break;
    
                case "this": // as an example of target words that the user may use when looking at an object
                case "it":  // as this is the default, these are not actually needed in this example
                case "that":
                default: // if the target name is none of those above, check if the user is looking at something
                    if (gazedTarget != null) 
                    {
                        targetAsGO = gazedTarget;
                    }
                    break;
            }
            return targetAsGO;
        }
    

    Wichtig

    Löschen Sie die Methoden Start() und Update(), da diese Klasse sie nicht verwendet.

  8. Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 8 – Erstellen der Blickklasse

Die letzte Klasse, die Sie ausführen müssen, ist die Gaze-Klasse . Diese Klasse aktualisiert den Verweis auf das GameObject derzeit im visuellen Fokus des Benutzers.

So erstellen Sie diese Klasse:

  1. Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.

  2. Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript "Gaze".

  3. Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

  4. Fügen Sie den folgenden Code für diese Klasse ein:

        using UnityEngine;
    
        public class Gaze : MonoBehaviour
        {        
            internal GameObject gazedObject;
            public float gazeMaxDistance = 300;
    
            void Update()
            {
                // Uses a raycast from the Main Camera to determine which object is gazed upon.
                Vector3 fwd = gameObject.transform.TransformDirection(Vector3.forward);
                Ray ray = new Ray(Camera.main.transform.position, fwd);
                RaycastHit hit;
                Debug.DrawRay(Camera.main.transform.position, fwd);
    
                if (Physics.Raycast(ray, out hit, gazeMaxDistance) && hit.collider != null)
                {
                    if (gazedObject == null)
                    {
                        gazedObject = hit.transform.gameObject;
    
                        // Set the gazedTarget in the Behaviours class
                        Behaviours.instance.gazedTarget = gazedObject;
                    }
                }
                else
                {
                    ResetGaze();
                }         
            }
    
            // Turn the gaze off, reset the gazeObject in the Behaviours class.
            public void ResetGaze()
            {
                if (gazedObject != null)
                {
                    Behaviours.instance.gazedTarget = null;
                    gazedObject = null;
                }
            }
        }
    
  5. Achten Sie darauf, Ihre Änderungen in Visual Studio zu speichern, bevor Sie zu Unity zurückkehren.

Kapitel 9 – Abschließen der Szeneneinrichtung

  1. Um die Einrichtung der Szene abzuschließen, ziehen Sie jedes Skript, das Sie aus dem Ordner "Skripts" erstellt haben, in das Hauptkameraobjekt im Hierarchiebereich.

  2. Wählen Sie die Hauptkamera aus, und sehen Sie sich den Inspektorbereich an, sie sollten in der Lage sein, jedes Skript anzuzeigen, das Sie angefügt haben, und Sie werden feststellen, dass es Parameter für jedes Skript gibt, das noch festgelegt werden soll.

    Setting the Camera Reference Targets.

  3. Führen Sie die folgenden Anweisungen aus, um diese Parameter ordnungsgemäß festzulegen:

    1. MicrophoneManager:

      • Ziehen Sie im Hierarchiebereich das Diktiertextobjekt in das Parameterwertfeld " Diktiertext ".
    2. Verhaltensweisen aus dem Hierarchiebereich:

      • Ziehen Sie das Sphere-Objekt in dasZielfeld kugelverweis.
      • Ziehen Sie den Zylinder in das Zylinderbezugszielfeld.
      • Ziehen Sie den Cube in das Cubereferenzzielfeld.
    3. Blick:

      • Legen Sie den max. Abstand des Blicks auf 300 fest (wenn er noch nicht vorhanden ist).
  4. Das Ergebnis sollte wie folgt aussehen:

    Showing the Camera Reference Targets, now set.

Kapitel 10 – Test im Unity-Editor

Testen Sie, dass das Setup der Szene ordnungsgemäß implementiert ist.

Stellen Sie Folgendes sicher:

  • Alle Skripts werden an das Hauptkameraobjekt angefügt.
  • Alle Felder im Hauptkameraprüfungsbereich werden ordnungsgemäß zugewiesen.
  1. Drücken Sie die Schaltfläche "Wiedergeben " im Unity-Editor. Die App sollte innerhalb des angefügten immersiven Headsets ausgeführt werden.

  2. Probieren Sie einige Ausdrücke aus, z. B.:

    make the cylinder red
    
    change the cube to yellow
    
    I want the sphere blue
    
    make this to green
    
    change it to white
    

    Hinweis

    Wenn in der Unity-Konsole ein Fehler zur Änderung des Standardaudiogeräts angezeigt wird, funktioniert die Szene möglicherweise nicht wie erwartet. Dies ist auf die Art und Weise, wie das Mixed Reality-Portal mit integrierten Mikrofonen für Headsets, die sie haben, behandelt. Wenn dieser Fehler angezeigt wird, beenden Sie einfach die Szene, und starten Sie sie erneut, und es sollte wie erwartet funktionieren.

Kapitel 11 – Erstellen und Querladen der UWP-Lösung

Nachdem Sie sichergestellt haben, dass die Anwendung im Unity-Editor funktioniert, können Sie Build und Deploy ausführen.

So erstellen Sie Folgendes:

  1. Speichern Sie die aktuelle Szene, indem Sie auf "Datei > speichern" klicken.

  2. Wechseln Sie zu "Dateibuild > Einstellungen".

  3. Aktivieren Sie das Kontrollkästchen " Unity C#-Projekte " (nützlich zum Anzeigen und Debuggen des Codes, sobald das UWP-Projekt erstellt wurde.

  4. Klicken Sie auf " Szenen hinzufügen", und klicken Sie dann auf "Erstellen".

    Build Settings window

  5. Sie werden aufgefordert, den Ordner auszuwählen, in dem Sie die Lösung erstellen möchten.

  6. Erstellen Sie einen BUILDS-Ordner , und erstellen Sie in diesem Ordner einen anderen Ordner mit einem geeigneten Namen Ihrer Wahl.

  7. Klicken Sie auf "Ordner auswählen ", um den Build an diesem Speicherort zu starten.

    Create Builds FolderSelect Builds Folder

  8. Sobald Unity das Gebäude abgeschlossen hat (es kann einige Zeit dauern), sollte es ein Explorer Fenster an der Position Ihres Builds öffnen.

So stellen Sie auf dem lokalen Computer bereit:

  1. Öffnen Sie in Visual Studio die Lösungsdatei, die im vorherigen Kapitel erstellt wurde.

  2. Wählen Sie in der Lösungsplattformx86, lokaler Computer aus.

  3. Wählen Sie in der Lösungskonfiguration"Debuggen" aus.

    Für die Microsoft HoloLens ist es möglicherweise einfacher, dies auf Remotecomputer festzulegen, sodass Sie nicht an Ihren Computer angebunden sind. Sie müssen jedoch auch Folgendes ausführen:

    • Kennen Sie die IP-Adresse Ihrer HoloLens, die im Einstellungen Netzwerk & internet > Wi-Fi >> erweiterten Optionen gefunden werden kann. IPv4 ist die Adresse, die Sie verwenden sollten.
    • Stellen Sie sicher, dass der Entwicklermodus aktiviert ist; in Einstellungen > Updatesicherheit &> für Entwickler gefunden.

    Deploy App

  4. Wechseln Sie zum Menü "Erstellen" , und klicken Sie auf "Lösung bereitstellen ", um die Anwendung auf Ihren Computer querzuladen.

  5. Ihre App sollte jetzt in der Liste der installierten Apps angezeigt werden, die zum Starten bereit sind!

  6. Sobald die App gestartet wurde, werden Sie aufgefordert, den Zugriff auf das Mikrofon zu autorisieren. Verwenden Sie die Bewegungscontroller oder die Spracheingabe oder die Tastatur , um die JA-Taste zu drücken.

Kapitel 12 – Verbesserung Ihres LUIS-Diensts

Wichtig

Dieses Kapitel ist unglaublich wichtig und muss möglicherweise mehrmals durchlaufen werden, da es ihnen hilft, die Genauigkeit Ihres LUIS-Diensts zu verbessern: Stellen Sie sicher, dass Sie dies abschließen.

Um das Verständnis von LUIS zu verbessern, müssen Sie neue Ausdrücke erfassen und sie verwenden, um Ihre LUIS-App neu zu trainieren.

Beispielsweise haben Sie LUIS möglicherweise geschult, um "Erhöhen" und "Upsize" zu verstehen, aber möchten Sie nicht, dass Ihre App auch Wörter wie "Vergrößern" verstehen soll?

Sobald Sie Ihre Anwendung ein paar Mal verwendet haben, werden alles, was Sie gesagt haben, von LUIS gesammelt und im LUIS-PORTAL verfügbar.

  1. Wechseln Sie zu Ihrer Portalanwendung nach diesem LINK, und melden Sie sich an.

  2. Sobald Sie mit Ihren MS-Anmeldeinformationen angemeldet sind, klicken Sie auf Ihren App-Namen.

  3. Klicken Sie links auf der Seite auf die Schaltfläche " Endpunkte überprüfen ".

    Review Utterances

  4. Sie werden eine Liste der Utterances angezeigt, die von Ihrer Mixed Reality-Anwendung an LUIS gesendet wurden.

    List of Utterances

Sie werden einige hervorgehobene Entitäten bemerken.

Indem Sie auf jedes hervorgehobene Wort zeigen, können Sie jede Utterance überprüfen und ermitteln, welche Entität richtig erkannt wurde, welche Entitäten falsch sind und welche Entitäten verpasst werden.

Im obigen Beispiel wurde festgestellt, dass das Wort "Spear" als Ziel hervorgehoben wurde, sodass es notwendig ist, den Fehler zu korrigieren, der durch Zeigen auf das Wort mit der Maus erfolgt und auf "Bezeichnung entfernen" klicken.

Check utterancesRemove Label Image

  1. Wenn Sie Utterances finden, die vollständig falsch sind, können Sie sie mithilfe der Schaltfläche "Löschen " auf der rechten Seite des Bildschirms löschen.

    Delete wrong utterances

  2. Oder wenn Sie der Ansicht sind, dass LUIS den Utterance richtig interpretiert hat, können Sie sein Verständnis überprüfen, indem Sie die Schaltfläche " Zu ausgerichteter Absicht hinzufügen " verwenden.

    Add to aligned intent

  3. Nachdem Sie alle angezeigten Utterances sortiert haben, versuchen Sie, die Seite neu zu laden, um festzustellen, ob mehr verfügbar ist.

  4. Es ist sehr wichtig, diesen Prozess so oft wie möglich zu wiederholen, um Ihr Anwendungsverständnis zu verbessern.

Viel Spaß!

Ihre fertige LUIS Integrated-Anwendung

Herzlichen Glückwunsch, Sie haben eine Mixed Reality-App erstellt, die den Azure Language Understanding Intelligence Service nutzt, um zu verstehen, was ein Benutzer sagt und auf diese Informationen reagiert.

Lab outcome

Zusatzübungen

Übung 1

Wenn Sie diese Anwendung verwenden, können Sie feststellen, dass sie beim Blick auf das Floor-Objekt und bitten, die Farbe zu ändern, dies geschieht. Können Sie herausfinden, wie Sie ihre Anwendung daran hindern, die Farbe "Boden" zu ändern?

Übung 2

Versuchen Sie, die LUIS- und App-Funktionen zu erweitern, und fügen Sie zusätzliche Funktionen für Objekte in szene hinzu; Erstellen Sie beispielsweise neue Objekte am Blickpunkt, je nachdem, was der Benutzer sagt, und können diese Objekte dann zusammen mit den aktuellen Szenenobjekten mit den vorhandenen Befehlen verwenden.