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

Artikel
07/04/2024

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 wird eine neue Reihe von Lernprogrammen geben, die in Zukunft veröffentlicht werden, die zeigen, wie sie für HoloLens 2 entwickelt werden. Dieser Hinweis wird mit einem Link zu diesen Lernprogrammen aktualisiert, wenn sie veröffentlicht werden.

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

Lab-Ergebnis

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

Nach Abschluss dieses Kurses haben Sie eine immersive Mixed Reality-Headset-Anwendung, die folgende Aktionen ausführen kann:

Erfassen Sie die Benutzereingabesprache mithilfe des Mikrofons, das an das immersive Headset angeschlossen ist.
Senden Sie das erfasste Diktat an den intelligenten Azure Language Understanding Service (LUIS).
Lassen Sie LUIS die Bedeutung aus den Sendeinformationen extrahieren, 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 Sprach- und/oder Blickeingabe verwenden kann, um die Größe und die Farbe der Objekte in der Szene zu ändern. Die Verwendung von Bewegungscontrollern wird nicht abgedeckt.

In Ihrer Anwendung liegt es an Ihnen, wie Sie die Ergebnisse in Ihr Design integrieren. Dieser Kurs wurde entwickelt, um Ihnen zu vermitteln, wie Sie einen Azure-Dienst in Ihr Unity-Projekt integrieren. Es ist Ihre Aufgabe, das Wissen zu nutzen, das Sie aus diesem Kurs gewinnen, um Ihre Mixed Reality-Anwendung zu verbessern.

Seien Sie mehrmals bereit, LUIS zu trainieren, der in Kapitel 12 behandelt wird. Sie erhalten bessere Ergebnisse, je mehr LUIS trainiert wurde.

Unterstützung für Geräte

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

Hinweis

Während sich dieser Kurs in erster Linie auf immersive Windows Mixed Reality-Headsets (VR) konzentriert, können Sie auch das, was Sie in diesem Kurs lernen, auf Microsoft HoloLens anwenden. Während Sie den Kurs befolgen, werden Notizen zu allen Änderungen angezeigt, die Sie möglicherweise zur Unterstützung von HoloLens verwenden müssen. Wenn Sie HoloLens verwenden, bemerken Sie möglicherweise ein Echo während der Sprachaufnahme.

Voraussetzungen

Hinweis

Dieses Lernprogramm wurde für Entwickler entwickelt, die grundlegende Erfahrung mit Unity und C# haben. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das zum Zeitpunkt der Schriftlichkeit (Mai 2018) getestet und überprüft wurden. Sie sind kostenlos, die neueste Software zu verwenden, wie im Artikel "Tools installieren" 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 die unten aufgeführten.

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

Ein Entwicklungs-PC, kompatibel mit Windows Mixed Reality für die Entwicklung von immersiven (VR)-Headsets
Windows 10 Fall Creators Update (oder höher) mit aktivierter Entwicklermodus
Das neueste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ein immersives Windows Mixed Reality-Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
Eine Reihe von Kopfhörern mit einem integrierten Mikrofon (wenn das Headset nicht über ein integriertes Mikrofon und Lautsprecher verfügt)
Internetzugriff für Azure-Setup und LUIS-Abruf

Vor der Installation

Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Lernprogramm erwähnte Projekt in einem Stamm- oder Near-Root-Ordner zu erstellen (lange Ordnerpfade können zu Buildzeit zu Problemen führen).
Um Ihrem Computer das Aktivieren von Diktieren zu ermöglichen, wechseln Sie zu Windows-Einstellungs-Datenschutzsprache > >, Freihandeingaben und -eingabe, und drücken Sie die Schaltfläche "Sprachdienste aktivieren" und Geben Sie Vorschläge ein.
Mit dem Code in diesem Lernprogramm können Sie von dem auf Ihrem Computer festgelegten Standardmikrofongerät aufzeichnen. Stellen Sie sicher, dass das Standardmikrofon als das Mikrofon festgelegt ist, das Sie zum Aufnehmen Ihrer Stimme verwenden möchten.
Wenn Ihr Headset über ein integriertes Mikrofon verfügt, stellen Sie sicher, dass die Option "Wenn ich mein Headset trage, zum Headset-Mikrofon wechseln" in den Mixed Reality-Portaleinstellungen aktiviert ist.

Kapitel 1 – Einrichten des Azure-Portals

Um den Sprachverständnisdienst in Azure zu verwenden, müssen Sie eine Instanz des Diensts konfigurieren, die Für Ihre Anwendung verfügbar gemacht werden soll.

Melden Sie sich beim Azure-Portalan.

Hinweis

Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Konto erstellen. Wenn Sie diesem Lernprogramm in einer Unterrichts- oder Laborsituation folgen, bitten Sie Ihren Kursleiter oder einen der Betreuer, Hilfe beim Einrichten Ihres neuen Kontos zu erhalten.
Nachdem Sie angemeldet sind, klicken Sie in der oberen linken Ecke auf "Neu ", suchen Sie nach "Sprachverständnis", und klicken Sie auf "Eingabetaste".

Hinweis

Das Wort "Neu" wurde möglicherweise durch "Ressource erstellen" in neueren Portalen ersetzt.
Die neue Seite rechts enthält eine Beschreibung des Sprachverständnisdiensts. Wählen Sie unten links auf dieser Seite die Schaltfläche "Erstellen " aus, um eine Instanz dieses Diensts zu erstellen.
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 das für Sie geeignete Preisniveau aus, wenn Sie zum ersten Mal einen LUIS-Dienst erstellen, sollte ihnen eine kostenlose Stufe (mit dem Namen F0) zur Verfügung stehen. Die kostenlose Zuteilung 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, die Abrechnung für eine Sammlung von Azure-Ressourcen zu überwachen, zu steuern, den Zugriff zu steuern, bereitzustellen und zu verwalten. Es wird empfohlen, alle Azure-Dienste, die einem einzelnen Projekt (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, besuchen Sie bitte den Artikel zur Ressourcengruppe.
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 würde. Einige Azure-Ressourcen sind nur in bestimmten Regionen verfügbar.
6. Sie müssen auch bestätigen, dass Sie die auf diesen Dienst angewendeten Allgemeinen Geschäftsbedingungen verstanden haben.
7. Klicken Sie auf Erstellen.
Nachdem Sie auf "Erstellen" geklickt haben, müssen Sie warten, bis der Dienst erstellt wurde. Dies kann eine Minute dauern.
Sobald die Dienstinstanz erstellt wurde, wird im Portal eine Benachrichtigung angezeigt.
Klicken Sie auf die Benachrichtigung, um Ihre neue Dienstinstanz zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche "Zur Ressource wechseln", um Ihre neue Dienstinstanz zu erkunden. Sie werden zur neuen LUIS-Dienstinstanz weitergeleitet.
In diesem Lernprogramm muss Ihre Anwendung Aufrufe an Ihren Dienst tätigen, was über den Abonnementschlüssel Ihres Diensts erfolgt.
Navigieren Sie auf der Schnellstartseite Ihres LUIS-API-Diensts zum ersten Schritt, greifen Sie ihre Schlüssel ab, und klicken Sie auf "Schlüssel". (Sie können dies auch erreichen, indem Sie auf die blauen Hyperlinktasten klicken, die sich im Navigationsmenü "Dienste" befinden, das durch das Schlüsselsymbol gekennzeichnet ist). Dadurch werden Ihre Dienstschlüssel angezeigt.
Erstellen Sie eine Kopie einer der angezeigten Schlüssel, da Sie dies später in Ihrem Projekt benötigen.
Klicken Sie auf der Seite "Dienst" auf das Sprachverständnisportal, um auf die Webseite umgeleitet zu werden, die Sie zum Erstellen Ihres neuen Diensts in der LUIS-App verwenden.

Kapitel 2 – Das Sprachverständnisportal

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 Utterances innerhalb dieses Kapitels nur der erste Schritt beim Erstellen Ihres LUIS-Diensts ist: Sie müssen den Dienst auch mehrmals neu trainieren, um ihn genauer zu gestalten. Die Umschulung Ihres Dienstes wird im letzten Kapitel dieses Kurses behandelt, um sicherzustellen, dass Sie ihn abschließen.

Wenn Sie das Sprachverständnisportal erreicht haben, müssen Sie sich möglicherweise anmelden, wenn Sie noch nicht sind, mit denselben Anmeldeinformationen wie Ihre Azure-Portal.
Wenn Sie LUIS zum ersten Mal verwenden, müssen Sie nach unten nach unten auf der Willkommensseite scrollen, um die Schaltfläche "LUIS-App erstellen" zu suchen und darauf zu klicken.
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.
Geben Sie der App einen Namen.
Wenn Ihre App eine andere Sprache als Englisch verstehen soll, sollten Sie die Kultur in die entsprechende Sprache ändern.
Hier können Sie auch eine Beschreibung Ihrer neuen LUIS-App hinzufügen.
Nachdem Sie auf "Fertig" geklickt haben, geben Sie die Seite "Build" der neuen LUIS-Anwendung ein.
Hier sind einige wichtige Konzepte zu verstehen:
- Intent, represents the method that will be called following a query from the user. Ein INTENT kann eine oder mehrere ENTITÄTen haben.
- Entität ist eine Komponente der Abfrage, die Informationen beschreibt, die für die ABSICHT relevant sind.
- Äußerungen sind Beispiele für Vom Entwickler bereitgestellte Abfragen, mit denen LUIS sich selbst trainieren wird.

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

Zunächst erstellen Sie die Entitäten, die zum Erstellen dieses Kurses erforderlich sind.

Klicken Sie auf der linken Seite der Seite auf Entitäten, und klicken Sie dann auf " Neue Entität erstellen".
Rufen Sie die neue Entitätsfarbe auf, legen Sie den Typ auf "Einfach" fest, und drücken Sie dann "Fertig".
Wiederholen Sie diesen Vorgang, um drei (3) weitere einfache Entitäten namens zu erstellen:
- Upsize
- gesundschrumpfen
- Ziel

Das Ergebnis sollte wie das folgende Bild aussehen:

Ergebnis der Entitätserstellung

An diesem Punkt können Sie mit dem Erstellen von Intents beginnen.

Warnung

Löschen Sie die Absicht "Keine" nicht.

Klicken Sie auf der linken Seite der Seite auf "Intents", und klicken Sie dann auf " Neue Absicht erstellen".
Rufen Sie die neue Intent ChangeObjectColor auf.

Wichtig

Dieser Intent-Name wird später in diesem Kurs im Code verwendet, um optimale Ergebnisse zu erzielen, verwenden Sie diesen Namen genau wie angegeben.

Nachdem Sie den Namen bestätigt haben, werden Sie zur Seite "Intents" weitergeleitet.

LUIS - Intents-Seite

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 Kleinbuchstaben.

Fügen Sie die folgende Äußerung in das obere Textfeld ein (derzeit mit dem Texttyp ca. 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 und den gesamten möglichen Verweis auf ein Ziel als Zielentität bezeichnen.

Klicken Sie dazu in der ersten Äußerung auf den Wortzylinder, und wählen Sie das Ziel aus.
Klicken Sie nun in der ersten Äußerung auf das rote Wort, und wählen Sie die Farbe aus.
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.
Wiederholen Sie den oben genannten Vorgang, bis alle Utterances die Entitäten beschriftet haben. Weitere Informationen finden Sie in der nachstehenden Abbildung, wenn Sie Hilfe benötigen.
Tipp

Wenn Sie Wörter auswählen, um sie als Entitäten zu beschriften, gelten folgende Regeln:
- Klicken Sie bei einzelnen Wörtern einfach darauf.
- Klicken Sie für eine Gruppe von zwei oder mehr Wörtern am Anfang und dann am Ende des Satzes.
Hinweis

Sie können die Umschaltfläche "Tokenansicht " verwenden, um zwischen Entitäten/Tokenansicht zu wechseln!
Die Ergebnisse sollten in den abbildungen unten dargestellt werden, die die Ansicht "Entitäten/Token" zeigen:
Drücken Sie an diesem Punkt die Schaltfläche "Trainieren " oben rechts auf der Seite, und warten Sie auf die kleine runde Anzeige darauf, um grün zu werden. Dies weist darauf hin, dass LUIS erfolgreich trainiert wurde, um diese Absicht zu erkennen.
Erstellen Sie als Übung für Sie eine neue Absicht namens "ChangeObjectSize" mit dem Ziel "Entities", "Upsize" und "Downsize".

Fügen Sie nach demselben Prozess wie der vorherige Intent die folgenden acht (8) Utterances für 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

Das Ergebnis sollte wie in der folgenden Abbildung aussehen:
Nachdem beide Intents, ChangeObjectColor und ChangeObjectSize, erstellt und trainiert wurden, klicken Sie oben auf der Seite auf die Schaltfläche "VERÖFFENTLICHEN ".
Auf der Seite "Veröffentlichen " werden Sie Ihre LUIS-App fertig stellen und veröffentlichen, damit sie von Ihrem Code aufgerufen werden kann.
1. Legen Sie die Dropdownliste "Als Produktion veröffentlichen in" 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".
Im Abschnitt Ressourcen und Schlüssel:
1. Wählen Sie die Region aus, die Sie für die Dienstinstanz im Azure-Portal festgelegt haben.
2. Sie werden sehen, dass ein Starter_Key Element unten ignoriert wird.
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 beim gleichen Benutzer angemeldet sind, werden Sie Dropdownmenüs für Mandantenname, Abonnementname und den Schlüssel bereitgestellt, den Sie verwenden möchten (hat denselben Namen wie zuvor im Azure-Portal angegeben).
Wichtig

Nehmen Sie unter Endpunkt eine Kopie des Endpunkts ab, der dem von Ihnen eingefügten Schlüssel entspricht, und verwenden Sie ihn in Kürze in Ihrem Code.

Kapitel 3 – Einrichten des Unity-Projekts

Im Folgenden sehen Sie eine typische Einrichtung für die Entwicklung mit mixed Reality und ist daher eine gute Vorlage für andere Projekte.

Öffnen Sie Unity , und klicken Sie auf "Neu".
Sie müssen nun einen Unity-Projektnamen angeben, MR_LUIS einfügen. Stellen Sie sicher, dass der Projekttyp auf 3D festgelegt ist. Legen Sie den Speicherort an einer für Sie geeigneten Stelle fest (denken Sie daran, dass die Stammverzeichnisse besser sind). Klicken Sie dann auf "Projekt erstellen".
Wenn Unity geöffnet ist, lohnt es sich, den Standardmäßigen Skript-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.
Wechseln Sie als Nächstes zu "Dateibuildeinstellungen>", und wechseln Sie zur Plattform zu Universelle Windows-Plattform, indem Sie auf die Schaltfläche "Plattform wechseln" klicken.
Wechseln Sie zu " Dateibuildeinstellungen > " , und stellen Sie sicher, dass:
1. Zielgerät ist auf "Beliebiges Gerät" festgelegt.
  
  Legen Sie für Microsoft HoloLens das Zielgerät auf 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 Ausführung ist auf den lokalen Computer festgelegt.
6. Speichern Sie die Szene, und fügen Sie sie dem Build hinzu.
  1. Wählen Sie dazu "Offene Szenen hinzufügen" aus. Ein Speicherfenster wird angezeigt.
  2. Erstellen Sie einen neuen Ordner für diese Und jede zukünftige Szene, und wählen Sie dann die Schaltfläche "Neuer Ordner " aus, um einen neuen Ordner zu erstellen, nennen Sie ihn "Szenen".
  3. Öffnen Sie den neu erstellten Ordner "Szenen", und drücken Sie dann im Feld "Dateiname: Textfeld", geben Sie MR_LuisScene ein, und drücken Sie dann "Speichern".
7. Die übrigen Einstellungen in den Buildeinstellungen sollten jetzt als Standard beibehalten werden.
Klicken Sie im Fenster "Buildeinstellungen " auf die Schaltfläche "Spielereinstellungen ". Dadurch wird der zugehörige Bereich im Bereich geöffnet, in dem sich der Inspektor befindet.
In diesem Bereich müssen einige Einstellungen überprüft werden:
1. Auf der Registerkarte "Andere Einstellungen" folgendes:
  1. Skripting Runtime-Version sollte stabil sein (.NET 3.5-Entsprechung).
  2. Scripting Back-End sollte .NET sein
  3. API-Kompatibilitätsstufe sollte .NET 4.6 sein
2. Aktivieren Sie auf der Registerkarte "Veröffentlichungseinstellungen " unter "Funktionen" Folgendes:
  1. InternetClient
  2. Mikrofon
3. Klicken Sie weiter unten im Bereich unter "XR-Einstellungen" (unter "Veröffentlichungseinstellungen" finden Sie auf "Virtual Reality Unterstützt"), und vergewissern Sie sich, dass das Windows Mixed Reality SDK hinzugefügt wird.
Zurück in Buildeinstellungen Unity C# -Projekte ist nicht mehr abgeblentet. Aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster Buildeinstellungen.
Speichern Sie Ihre Szene und Ihr Projekt (FILE > SAVE SCENE / FILE > SAVE PROJECT).

Kapitel 4 – Erstellen der Szene

Wichtig

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

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs unter 3D-Objekt, und fügen Sie eine Ebene hinzu.
Beachten Sie, dass das ausgewählte Objekt, wenn Sie mit der rechten Maustaste in die Hierarchie klicken, 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.
Wiederholen Sie die obige Prozedur, um die folgenden Objekte hinzuzufügen:
1. Kugel
2. Zylinder
3. Cube
4. 3D-Text
Die resultierende Szenenhierarchie sollte wie in der abbildung unten dargestellten sein:
Klicken Sie mit der linken Maustaste auf die Hauptkamera , um sie auszuwählen, sehen Sie sich den Inspektorbereich an, in dem das Kameraobjekt mit allen zugehörigen Komponenten angezeigt wird.
Klicken Sie unten im Inspektorbereich auf die Schaltfläche "Komponente hinzufügen".
Suchen Sie nach der Komponente namens "Audioquelle", wie oben gezeigt.
Stellen Sie außerdem sicher, dass die Transformationskomponente der Hauptkamera auf (0,0,0) festgelegt ist, 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 microsoft HoloLens müssen Sie auch Folgendes ändern, das Teil der Kamerakomponente ist, die sich auf der Hauptkamera befindet:
- Flags löschen: Volltonfarbe.
- Hintergrund 'Schwarz, Alpha 0' – Hexfarbe: #000000000.
Klicken Sie mit der linken Maustaste auf die Ebene , um sie auszuwählen. Legen Sie im Inspektorbereich die Transform-Komponente mit den folgenden Werten fest:

X-Achse Y-Achse Z-Achse

0 -1 0
Klicken Sie mit der linken Maustaste auf die Kugel , um sie auszuwählen. Legen Sie im Inspektorbereich die Transform-Komponente mit den folgenden Werten fest:

X-Achse Y-Achse Z-Achse

2 1 2
Klicken Sie mit der linken Maustaste auf den Zylinder , um ihn auszuwählen. Legen Sie im Inspektorbereich die Transform-Komponente mit den folgenden Werten fest:

X-Achse Y-Achse Z-Achse

-2 1 2
Klicken Sie mit der linken Maustaste auf den Cube , um ihn auszuwählen. Legen Sie im Inspektorbereich die Transform-Komponente mit den folgenden Werten fest:

X-Achse	Y-Achse	Z-Achse
0	-1	0

X-Achse	Y-Achse	Z-Achse
2	1	2

X-Achse	Y-Achse	Z-Achse
-2	1	2

Transformieren – Position

X	Y	Z
0	1	4

Transformation – Drehung

X	Y	Z
45	45	0

Klicken Sie mit der linken Maustaste auf das Objekt "Neuer Text ", um es auszuwählen. Legen Sie im Inspektorbereich die Transform-Komponente mit den folgenden Werten fest:

Transformieren – Position

X	Y	Z
-2	6	9

Transformation – Skalierung

X	Y	Z
0,1	0,1	0,1

Ändern Sie den Schriftgrad in der Textgitterkomponente auf 50.
Ändern Sie den Namen des Text Mesh-Objekts in Diktiertext.
Ihre Hierarchiepanelstruktur sollte nun wie folgt aussehen:
Die letzte Szene sollte wie das folgende Bild aussehen:

Kapitel 5 – Erstellen der MicrophoneManager-Klasse

Das erste Skript, das Sie erstellen möchten, ist die MicrophoneManager-Klasse . Auf diese Weise 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 behandelt wird, wenn Sie jedes Kapitel erreichen).

Die MicrophoneManager-Klasse ist für Folgendes verantwortlich:

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

So erstellen Sie diese Klasse:

Klicken Sie mit der rechten Maustaste in den Projektbereich, Ordner erstellen>. Rufen Sie den Ordner Skripts auf.
Doppelklicken Sie beim Erstellen des Skriptordners darauf, um ihn zu öffnen. Klicken Sie dann in diesem Ordner mit der rechten Maustaste auf "C#-Skript erstellen > ". Nennen Sie das Skript "MicrophoneManager".
Doppelklicken Sie auf "MicrophoneManager ", um ihn mit Visual Studio zu öffnen.

Fügen Sie am Anfang der -Datei die folgenden Namespaces hinzu:

    using UnityEngine;
    using UnityEngine.Windows.Speech;

Fügen Sie dann die folgenden Variablen in der MicrophoneManager-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

Code für Die Methoden Awake() und Start() muss jetzt hinzugefügt werden. Diese werden 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");
        }
    }

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 in Kürze 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...");
    }

Fügen Sie einen Diktierhandler hinzu, der aufgerufen wird, wenn die Stimme angehalten wird. Diese Methode übergibt den Diktiertext an die LuisManager-Klasse .

    /// <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.

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

Hinweis

An diesem Punkt werden Sie feststellen, dass im Unity Editor Console Panel ein Fehler angezeigt wird. 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 sendet.

Der Zweck dieser Klasse besteht darin, den Diktiertext aus der MicrophoneManager-Klasse zu empfangen und an die zu analysierende Azure Language Understanding-API zu senden.

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:

Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript LuisManager.
Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

Fügen Sie am Anfang der -Datei die folgenden Namespaces hinzu:

    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.IO;
    using UnityEngine;
    using UnityEngine.Networking;

Zunächst erstellen Sie 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;
    }

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";

Stellen Sie sicher, dass Sie ihren LUIS-Endpunkt jetzt platzieren (den Sie über Ihr LUIS-Portal haben).

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;
    }

Jetzt benötigen Sie die Methoden, die diese Anwendung verwendet, um das diktieren, das von der MicrophoneManager-Klasse empfangen wurde, an LUIS zu senden und dann die Antwort zu empfangen und deserialisieren.

Sobald der Wert des Intent und der zugeordneten Entitäten bestimmt wurden, 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;
        }
    }

Erstellen Sie eine neue Methode namens AnalyseResponseElements(), die die resultierende AnalyseAbfrage 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.

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 Behaviors-Klasse verweist, die Sie im nächsten Kapitel erstellen werden.

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:

Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript " Behaviors".
Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

Fügen Sie dann die folgenden Variablen in 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;

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;
    }

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);
    }

Fügen Sie die FindTarget()- Methode hinzu, um zu bestimmen, welche der GameObjects das Ziel der aktuellen Absicht ist. Mit dieser Methode wird standardmäßig das Ziel auf das GameObject "gazed" festgelegt, 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.

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

Kapitel 8 – Erstellen der Gaze-Klasse

Die letzte Klasse, die Sie zum Abschließen dieser App benötigen, ist die Gaze-Klasse . Diese Klasse aktualisiert den Verweis auf das GameObject, das sich derzeit im visuellen Fokus des Benutzers befindet.

So erstellen Sie diese Klasse:

Doppelklicken Sie auf den Ordner "Skripts ", um ihn zu öffnen.
Klicken Sie mit der rechten Maustaste in den Ordner "Skripts", und klicken Sie auf "C#-Skript erstellen>". Nennen Sie das Skript "Gaze".
Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

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;
            }
        }
    }

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

Kapitel 9 – Abschließen der Szeneneinrichtung

Um die Einrichtung der Szene abzuschließen, ziehen Sie jedes Skript, das Sie aus dem Ordner "Skripts" erstellt haben, in das Hauptkameraobjekt im Hierarchiebereich.
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 für jedes Skript Parameter vorhanden sind, die noch festgelegt werden müssen.
Gehen Sie wie folgt vor, um diese Parameter richtig festzulegen:
1. MicrophoneManager:
  - Ziehen Sie im Hierarchiebereich das Diktattext-Objekt in das Wertfeld des Diktiertextparameters.
2. Verhalten aus dem Hierarchiebereich:
  - Ziehen Sie das Sphere-Objekt in das Kugelbezugszielfeld.
  - Ziehen Sie den Zylinder in das Zylinderbezugszielfeld.
  - Ziehen Sie den Cube in das Zielfeld des Cubeverweises.
3. Blick:
  - Legen Sie den maximalen Blickabstand auf 300 fest (sofern dies noch nicht geschehen ist).
Das Ergebnis sollte wie das folgende Bild aussehen:

Kapitel 10 – Test im Unity-Editor

Testen Sie, dass das Szenensetup ordnungsgemäß implementiert ist.

Stellen Sie Folgendes sicher:

Alle Skripts sind an das Main Camera-Objekt angefügt.
Alle Felder im Hauptkameraprüfungsbereich werden ordnungsgemäß zugewiesen.

Drücken Sie die Wiedergabeschaltfläche im Unity-Editor. Die App sollte innerhalb des angeschlossenen immersiven Headsets ausgeführt werden.
Probieren Sie einige Äußerungen 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 zum Ändern des Standardaudiogeräts angezeigt wird, funktioniert die Szene möglicherweise nicht wie erwartet. Dies liegt daran, wie sich das Mixed Reality-Portal mit integrierten Mikrofonen für Headsets befasst, die über sie verfügen. Wenn dieser Fehler angezeigt wird, beenden Sie einfach die Szene, und starten Sie sie erneut, und die Dinge sollten 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 erstellen und bereitstellen.

So erstellen Sie Folgendes:

Speichern Sie die aktuelle Szene, indem Sie auf " Datei > speichern" klicken.
Wechseln Sie zu " Dateibuildeinstellungen > ".
Tick the box called Unity C# Projects (useful for seeing and debugging your code once the UWP project is created.
Klicken Sie auf " Offene Szenen hinzufügen", und klicken Sie dann auf " Erstellen".
Sie werden aufgefordert, den Ordner auszuwählen, in dem Sie die Lösung erstellen möchten.
Erstellen Sie einen BUILDS-Ordner , und erstellen Sie in diesem Ordner einen anderen Ordner mit einem geeigneten Namen Ihrer Wahl.
Klicken Sie auf " Ordner auswählen", um den Build an diesem Speicherort zu starten.
Nachdem Unity das Erstellen abgeschlossen hat (es kann einige Zeit dauern), sollte ein Explorer Fenster am Speicherort Ihres Builds geöffnet werden.

So stellen Sie auf dem lokalen Computer bereit:

Öffnen Sie in Visual Studio die Projektmappendatei, die im vorherigen Kapitel erstellt wurde.
Wählen Sie in der Lösungsplattform x86, lokaler Computer aus.
Wählen Sie in der Lösungskonfiguration "Debuggen" aus.
Für Microsoft HoloLens ist es möglicherweise einfacher, dies auf Remotecomputer festzulegen, sodass Sie nicht an Ihren Computer angebunden sind. Sie müssen jedoch auch die folgenden Schritte ausführen:
- Kennen Sie die IP-Adresse Ihrer HoloLens, die sich in den erweiterten Optionen für Netzwerkeinstellungen > und Internet > wi-Fi > befindet. IPv4 ist die Adresse, die Sie verwenden sollten.
- Stellen Sie sicher, dass der Entwicklermodus aktiviert ist; finden Sie in "Einstellungen > Update & Sicherheit > für Entwickler".
Wechseln Sie zum Menü "Erstellen" , und klicken Sie auf " Lösung bereitstellen", um die Anwendung auf Ihren Computer querzuladen.
Ihre App sollte jetzt in der Liste der installierten Apps angezeigt werden und kann gestartet werden!
Nach dem Start fordert die App Sie auf, 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-Dienstes

Wichtig

Dieses Kapitel ist unglaublich wichtig und muss möglicherweise mehrmals durchlaufen werden, da es dazu beitragen wird, 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 Äußerungen erfassen und sie verwenden, um Ihre LUIS-App neu zu trainieren.

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

Sobald Sie Ihre Anwendung ein paar Mal verwendet haben, werden alles, was Sie gesagt haben, von LUIS gesammelt und im LUIS PORTAL zur Verfügung gestellt.

Wechseln Sie zu Ihrer Portalanwendung, die diesem LINK folgt, und melden Sie sich an.
Nachdem Sie mit Ihren MS-Anmeldeinformationen angemeldet sind, klicken Sie auf Ihren App-Namen.
Klicken Sie links auf der Seite auf die Schaltfläche "Endpunkt-Äußerungen überprüfen".
Sie werden eine Liste der Utterances angezeigt, die von Ihrer Mixed Reality-Anwendung an LUIS gesendet wurden.

Sie werden einige hervorgehobene Entitäten bemerken.

Wenn Sie auf jedes hervorgehobene Wort zeigen, können Sie jede Utterance überprüfen und bestimmen, 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 "Speer" als Ziel hervorgehoben wurde, sodass es notwendig ist, den Fehler zu korrigieren, der durch Zeigen auf das Wort mit der Maus und klicken auf "Beschriftung entfernen".

Überprüfen von Äußerungen Beschriftungsbild entfernen

Wenn Sie Utterances finden, die völlig falsch sind, können Sie sie mithilfe der Schaltfläche "Löschen " auf der rechten Seite des Bildschirms löschen.
Oder wenn Sie den Eindruck haben, dass LUIS die Utterance richtig interpretiert hat, können Sie dessen Verständnis überprüfen, indem Sie die Schaltfläche "Zu ausgerichteter Absicht hinzufügen" verwenden.
Nachdem Sie alle angezeigten Äußerungen sortiert haben, versuchen Sie, die Seite neu zu laden, um festzustellen, ob weitere verfügbar sind.
Es ist sehr wichtig, diesen Prozess so oft wie möglich zu wiederholen, um Ihr Anwendungsverständnis zu verbessern.

Viel Spass!

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-Ergebnis

Zusatzübungen

Übung 1

Wenn Sie diese Anwendung verwenden, bemerken Sie möglicherweise, dass sie beim Betrachten des Floor-Objekts und beim Ändern der Farbe dies tun wird. Können Sie herausfinden, wie Sie ihre Anwendung daran hindern, die Farbe des Bodens zu ändern?

Übung 2

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

Freigeben über

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

Unterstützung für Geräte

Voraussetzungen

Vor der Installation

Kapitel 1 – Einrichten des Azure-Portals

Kapitel 2 – Das Sprachverständnisportal

Kapitel 3 – Einrichten des Unity-Projekts

Kapitel 4 – Erstellen der Szene

Kapitel 5 – Erstellen der MicrophoneManager-Klasse

Kapitel 6 – Erstellen der LUISManager-Klasse

Kapitel 7 – Erstellen der Verhaltensklasse

Kapitel 8 – Erstellen der Gaze-Klasse

Kapitel 9 – Abschließen der Szeneneinrichtung

Kapitel 10 – Test im Unity-Editor

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

Kapitel 12 – Verbesserung Ihres LUIS-Dienstes

Ihre fertige LUIS Integrated Anwendung

Zusatzübungen

Übung 1

Übung 2

Zusätzliche Ressourcen