HoloLens (1. Generation) und Azure 303: Natural Language Understanding (LUIS)

Artikel
07/12/2023

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

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

Labergebnis

Language Understanding (LUIS) ist ein Microsoft Azure-Dienst, der Anwendungen die Möglichkeit bietet, aus Benutzereingaben Eine Bedeutung zu machen, z. B. durch extrahieren, was eine Person in ihren eigenen Worten haben könnte. 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 verfügen Sie über eine immersive Mixed Reality-Headset-Anwendung, die folgendes ausführen kann:

Erfassen Sie die Sprache der Benutzereingabe mithilfe des Mikrofons, das an das immersive Headset angeschlossen ist.
Senden Sie das erfasste Diktat an azure Language Understanding Intelligent Service (LUIS).
Lassen Sie luis die Bedeutung aus den Sendeinformationen extrahieren, die analysiert werden, und versuchen Sie, die Absicht der Anforderung des Benutzers zu bestimmen.

Die Entwicklung umfasst die Erstellung einer App, bei der der Benutzer die Größe und Farbe der Objekte in der Szene mithilfe von Sprache und/oder Blick ändern kann. Der Einsatz von Bewegungscontrollern wird nicht abgedeckt.

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

Seien Sie darauf vorbereitet, LUIS mehrmals zu trainieren, was in Kapitel 12 behandelt wird. Sie erhalten bessere Ergebnisse, je öfter LUIS trainiert wurde.

Geräteunterstützung

Kurs	HoloLens	Immersive Headsets
MR und Azure 303: Natural Language Understanding (LUIS)	✔️	✔️

Hinweis

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

Voraussetzungen

Hinweis

Dieses Tutorial richtet sich an Entwickler, die über grundlegende Erfahrungen mit Unity und C# verfügen. Bitte beachten Sie auch, dass die Voraussetzungen und schriftlichen Anweisungen in diesem Dokument das darstellen, was zum Zeitpunkt des Schreibens (Mai 2018) getestet und überprüft wurde. Sie können die neueste Software verwenden, wie im Artikel Installieren der Tools aufgeführt, aber es sollte nicht davon ausgegangen werden, dass die Informationen in diesem Kurs perfekt dem entsprechen, was Sie in neuerer Software finden, als die unten aufgeführten.

Wir empfehlen die folgende Hard- 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 aktiviertem Entwicklermodus
Das neueste Windows 10 SDK
Unity 2017.4
Visual Studio 2017
Ein Windows Mixed Reality immersives Headset (VR) oder Microsoft HoloLens mit aktiviertem Entwicklermodus
Kopfhörer mit integriertem Mikrofon (wenn das Headset nicht über ein integriertes Mikrofon und Lautsprecher verfügt)
Internetzugriff für Azure-Setup und LUIS-Abruf

Vorbereitung

Um Probleme beim Erstellen dieses Projekts zu vermeiden, wird dringend empfohlen, das in diesem Tutorial erwähnte Projekt in einem Stamm- oder Fast-Root-Ordner zu erstellen (lange Ordnerpfade können zur Buildzeit Zu Problemen führen).
Damit Ihr Computer das Diktieren aktivieren kann, wechseln Sie zu Windows-Einstellungen > Privacy > Speech, Inking & Eingabe , und drücken Sie die Schaltfläche Sprachdienste aktivieren und Vorschläge eingeben.
Mit dem Code in diesem Tutorial können Sie die Aufzeichnung über das Standardmikrofongerät auf Ihrem Computer ausführen. Stellen Sie sicher, dass das Standardmikrofongerät auf das festgelegt ist, das Sie zum Erfassen 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 Headsetmikrofon wechseln" in den Mixed Reality Portal-Einstellungen aktiviert ist.

Kapitel 1: Einrichten des Azure-Portals

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

Melden Sie sich beim Azure-Portal an.

Hinweis

Wenn Sie noch nicht über ein Azure-Konto verfügen, müssen Sie ein Azure-Konto erstellen. Wenn Sie dieses Tutorial in einer Unterrichts- oder Labsituation befolgen, bitten Sie Ihren Kursleiter oder einen der Verantwortlichen um Hilfe beim Einrichten Ihres neuen Kontos.
Nachdem Sie angemeldet sind, klicken Sie oben links auf Neu, suchen Sie nach Language Understanding, und klicken Sie auf DIE EINGABETASTE.

Hinweis

Das Wort Neu wurde in neueren Portalen möglicherweise durch Ressource erstellen ersetzt.
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 instance dieses Diensts zu erstellen.
Nachdem Sie auf Erstellen geklickt haben:
1. Fügen Sie den gewünschten Namen für diesen Dienst instance ein.
2. Wählen Sie ein Abonnementaus.
3. Wählen Sie den für Sie geeigneten Tarif aus. Wenn Sie zum ersten Mal einen LUIS-Dienst erstellen, sollte ihnen ein kostenloser Tarif (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 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 (z. B. diesen Kursen) zugeordnet sind, unter einer gemeinsamen Ressourcengruppe zu halten.
  
  Wenn Sie mehr über Azure-Ressourcengruppen erfahren möchten, lesen Sie den Artikel Ressourcengruppe.
5. Bestimmen Sie den Speicherort für Ihre Ressourcengruppe (wenn Sie eine neue Ressourcengruppe erstellen). Der Speicherort befindet sich 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 für diesen Dienst geltenden Geschäftsbedingungen verstanden haben.
7. Klicken Sie auf Erstellen.
Nachdem Sie auf Erstellen geklickt haben, müssen Sie warten, bis der Dienst erstellt wird. Dies kann eine Minute dauern.
Eine Benachrichtigung wird im Portal angezeigt, sobald der Dienst instance erstellt wurde.
Klicken Sie auf die Benachrichtigung, um Ihre neue Dienst-instance zu erkunden.
Klicken Sie in der Benachrichtigung auf die Schaltfläche Zu Ressource wechseln, um Ihren neuen Dienst instance zu erkunden. Sie werden zu Ihrem neuen LUIS-Dienst instance weitergeleitet.
In diesem Tutorial muss Ihre Anwendung Aufrufe an Ihren Dienst tätigen, was mithilfe des Abonnementschlüssels Ihres Diensts erfolgt.
Navigieren Sie auf der Schnellstartseite Ihres LUIS-API-Diensts zum ersten Schritt, greifen Sie Ihre Schlüssel, und klicken Sie auf Schlüssel (Sie können dies auch erreichen, indem Sie auf den blauen Link Schlüssel klicken, der sich im Navigationsmenü dienste befindet und durch das Schlüsselsymbol gekennzeichnet ist). Dadurch werden Ihre Dienstschlüssel angezeigt.
Erstellen Sie eine Kopie eines der angezeigten Schlüssel, da Sie dies später in Ihrem Projekt benötigen.
Klicken Sie auf der Seite Dienst auf Language Understanding Portal, um zu der Webseite weitergeleitet 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

Beachten Sie, dass das Einrichten der Entitäten, Absichten und Äußerungen in diesem Kapitel nur der erste Schritt beim Erstellen Ihres LUIS-Diensts ist: Sie müssen den Dienst auch mehrmals erneut trainieren, um ihn genauer zu machen. Das erneute Trainieren Ihres Diensts wird im letzten Kapitel dieses Kurses behandelt. Stellen Sie also sicher, dass Sie ihn abschließen.

Wenn Sie das Language Understanding Portal erreichen, müssen Sie sich ggf. mit denselben Anmeldeinformationen wie Ihre Azure-Portal anmelden, falls Sie dies noch nicht getan haben.
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.
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, gelangen Sie zur Seite Build ihrer neuen LUIS-Anwendung .
Hier sind einige wichtige Konzepte zu verstehen:
- Absicht, stellt die Methode dar, die nach einer Abfrage des Benutzers aufgerufen wird. Eine ABSICHT kann über eine oder mehrere ENTITÄTen verfügen.
- Die Entität ist eine Komponente der Abfrage, die informationen beschreibt, die für die ABSICHT relevant sind.
- Äußerungen sind Beispiele für Abfragen, die vom Entwickler bereitgestellt werden, die LUIS verwendet, um sich selbst zu trainieren.

Wenn diese Konzepte nicht ganz klar sind, machen Sie sich keine Sorgen, da dieser Kurs sie in diesem Kapitel weiter verdeutlichen wird.

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

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

Das Ergebnis sollte wie in der folgenden Abbildung aussehen:

Ergebnis der Entitätserstellung

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

Warnung

Löschen Sie die Absicht None nicht.

Klicken Sie links auf der Seite auf Absichten, und klicken Sie dann auf Neue Absicht erstellen.
Rufen Sie die neue AbsichtChangeObjectColor auf.

Wichtig

Dieser Absichtsname wird später im Code dieses Kurses verwendet, daher verwenden Sie diesen Namen genau wie angegeben, um optimale Ergebnisse zu erzielen.

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

LUIS – Seite

Sie werden feststellen, dass es ein Textfeld gibt, in dem Sie aufgefordert werden, 5 oder mehr verschiedene Äußerungen einzugeben.

Hinweis

LUIS konvertiert alle Äußerungen in Kleinbuchstaben.

Fügen Sie die folgende Äußerung in das obere Textfeld ein (derzeit mit dem Text Typ etwa 5 Beispiele... ), und drücken Sie die EINGABETASTE:

The color of the cylinder must be red

Sie werden feststellen, dass die neue Äußerung in einer Liste darunter angezeigt wird.

Fügen Sie nach demselben Prozess die folgenden sechs (6) Äußerungen 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 Äußerung müssen Sie identifizieren, welche Wörter von LUIS als Entitäten verwendet werden sollen. In diesem Beispiel müssen Sie alle Farben als Farbentität und alle möglichen Verweise auf ein Ziel als Zielentität bezeichnen.

Klicken Sie dazu in der ersten Äußerung auf das Wort Zylinder , und wählen Sie Ziel aus.
Klicken Sie nun in der ersten Äußerung auf das Wort rot , und wählen Sie die Farbe aus.
Bezeichnen Sie auch die nächste Zeile, wobei cube ein Ziel und Schwarz eine Farbe sein sollte. 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 obigen Vorgang, bis alle Äußerungen die Entitäten beschriftet haben. Sehen Sie sich die folgende Abbildung an, wenn Sie Hilfe benötigen.
Tipp

Wenn Sie Wörter auswählen, um sie als Entitäten zu beschriften, gelten folgende Regeln:
- Für einzelne Wörter klicken Sie einfach darauf.
- Für einen Satz von zwei oder mehr Wörtern klicken Sie 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 wie in den folgenden Abbildungen dargestellt sein, die die Ansicht Entitäten/Token zeigen:
Klicken Sie an diesem Punkt oben rechts auf der Seite auf die Schaltfläche Trainieren , und warten Sie, bis der kleine runde Indikator grün wird. Dies gibt an, dass LUIS erfolgreich trainiert wurde, um diese Absicht zu erkennen.
Erstellen Sie als Übung für Sie eine neue Absicht namens ChangeObjectSize, indem Sie das Ziel Entitäten verwenden, upsize und downsize verwenden.

Fügen Sie nach demselben Prozess wie bei der vorherigen Absicht die folgenden acht (8) Äußerungen 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 Absichten, 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 fertigstellen und veröffentlichen, damit Ihr Code darauf zugreifen kann.
1. Legen Sie die Dropdownliste Veröffentlichen in als Produktion fest.
2. Legen Sie die Zeitzone auf Ihre Zeitzone fest.
3. Aktivieren Sie das Kontrollkästchen Alle vorhergesagten Absichtsbewertungen einschließen.
4. Klicken Sie auf Im Produktionsslot veröffentlichen.
Im Abschnitt Ressourcen und Schlüssel:
1. Wählen Sie die Region aus, die Sie für den Dienst instance im Azure-Portal festgelegt haben.
2. Sie werden ein Starter_Key-Element unten bemerken, ignorieren Sie es.
3. Klicken Sie auf Schlüssel hinzufügen, und fügen Sie den Schlüssel ein, den Sie im Azure-Portal erhalten haben, als Sie Ihre Dienst-instance erstellt haben. Wenn Ihr Azure-Portal und das LUIS-Portal bei demselben Benutzer angemeldet sind, werden Ihnen Dropdownmenüs für Mandantenname, Abonnementname und den Schlüssel bereitgestellt, den Sie verwenden möchten (haben denselben Namen, den Sie zuvor im Azure-Portal angegeben haben.
Wichtig

Erstellen Sie unter Endpunkt eine Kopie des Endpunkts, der dem von Ihnen eingefügten Schlüssel entspricht. Sie werden ihn bald in Ihrem Code verwenden.

Kapitel 3: Einrichten des Unity-Projekts

Im Folgenden wird ein typischer Aufbau für die Entwicklung mit Mixed Reality dargestellt 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 auf einen für Sie geeigneten Ort fest (denken Sie daran, dass näher an Stammverzeichnissen besser ist). Klicken Sie dann auf Projekt erstellen.
Wenn Unity geöffnet ist, lohnt es sich, zu überprüfen, ob der Standardskript-Editor auf Visual Studio festgelegt ist. Navigieren 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 die Plattform auf 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 die Microsoft HoloLens Zielgerät auf HoloLens fest.
2. Buildtyp ist auf D3D festgelegt
3. SDK ist auf Zuletzt installiert festgelegt.
4. Visual Studio-Version ist auf Zuletzt installiert festgelegt.
5. Build and Run ist auf Lokaler 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. Es wird ein Fenster zum Speichern 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, und nennen Sie ihn Szenen.
  3. Öffnen Sie den neu erstellten Ordner Scenes , und geben Sie dann im Textfeld Dateiname: MR_LuisScene ein, und drücken Sie dann Speichern.
7. Die restlichen Einstellungen in Buildeinstellungen sollten vorerst als Standard beibehalten werden.
Klicken Sie im Fenster Buildeinstellungen auf die Schaltfläche Playereinstellungen . Dadurch wird der zugehörige Bereich in dem 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 :
  1. Die Skriptlaufzeitversion sollte stabil (.NET 3.5 gleichwertig) sein.
  2. Skript-Back-End sollte .NET sein
  3. API-Kompatibilitätsgrad sollte .NET 4.6 sein
2. Überprüfen Sie auf der Registerkarte Veröffentlichungseinstellungen unter Funktionen Folgendes:
  1. InternetClient
  2. Mikrofon
3. Wählen Sie weiter unten im Bereich unter XR-Einstellungen (unter Veröffentlichungseinstellungen) die Option Virtual Reality Supported (Virtual Reality Supported) aus, stellen Sie sicher, dass das Windows Mixed Reality SDK hinzugefügt wurde.
Zurück in BuildeinstellungenUnity C#- Projekte ist nicht mehr abgeblendet. aktivieren Sie das Kontrollkästchen neben diesem.
Schließen Sie das Fenster „Build Settings“ (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 dem Code fortfahren möchten, können Sie dieses UnityPackage herunterladen, es als benutzerdefiniertes Paket in Ihr Projekt importieren und dann mit Kapitel 5 fortfahren.

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Hierarchiebereichs, und fügen Sie unter 3D-Objekt eine Ebene hinzu.
Beachten Sie, dass das ausgewählte Objekt das übergeordnete Objekt des neuen Objekts ist, wenn Sie erneut mit der rechten Maustaste in die Hierarchie klicken, um weitere Objekte zu erstellen. Vermeiden Sie, dass Sie mit der linken Maustaste in einen leeren Bereich innerhalb der Hierarchie klicken und dann mit der rechten Maustaste darauf klicken.
Wiederholen Sie die obige Prozedur, um die folgenden Objekte hinzuzufügen:
1. Sphere
2. Zylinder
3. Cube
4. 3D-Text
Die resultierende Szenenhierarchie sollte wie in der folgenden Abbildung aussehen:
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 ganz unten im Inspektorbereich auf die Schaltfläche Komponente hinzufügen.
Suchen Sie wie oben gezeigt nach der Komponente Audioquelle.
Stellen Sie außerdem sicher, dass die Transformationskomponente der Hauptkamera auf (0,0,0) festgelegt ist. Hierzu können Sie das Zahnradsymbol neben der Komponente Transformieren 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. Die Drehung ist auf 0, 0, 0 festgelegt.
Hinweis

Für die Microsoft HoloLens müssen Sie auch Folgendes ändern, das Teil der Kamerakomponente ist, die sich auf Ihrer Hauptkamera befindet:
- Flags löschen: Volltonfarbe.
- Hintergrund "Schwarz, Alpha 0" – Sechskantfarbe: #0000000000.
Klicken Sie mit der linken Maustaste 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
Klicken Sie mit der linken Maustaste 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
Klicken Sie mit der linken Maustaste 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
Klicken Sie mit der linken Maustaste auf den Cube , um ihn auszuwählen. Legen Sie im Inspektorbereich die Transformationskomponente 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	J	Z
0	1	4

Transformation – Drehung

X	J	Z
45	45	0

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

Transformieren – Position

X	J	Z
-2	6	9

Transformieren – Skalieren

X	J	Z
0,1	0,1	0,1

Ändern Sie den Schriftgrad in der Text mesh-Komponente in 50.
Ändern Sie den Namen des Text Mesh-Objekts in Diktiertext.
Ihre Struktur des Hierarchiebereichs sollte nun wie folgt aussehen:
Die letzte Szene sollte wie die folgende Abbildung aussehen:

Kapitel 5: Erstellen der MicrophoneManager-Klasse

Das erste Skript, das Sie erstellen, ist die MicrophoneManager-Klasse . Anschließend erstellen Sie die LuisManager-Klasse, die Behaviours-Klasse und zuletzt die Gaze-Klasse (sie können jetzt alle erstellen, obwohl sie behandelt wird, sobald Sie jedes Kapitel erreichen).

Die MicrophoneManager-Klasse ist für Folgendes verantwortlich:

Erkennen des am Headset oder Computer angeschlossenen Aufzeichnungsgeräts (je nachdem, welches das Standardgerät ist).
Erfassen Sie das Audio (Voice) und verwenden Sie diktation, um es 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 im Projektbereichauf Ordner erstellen>. Rufen Sie den Ordner Skripts auf.
Doppelklicken Sie beim Erstellen des Ordners Skripts 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 es mit Visual Studio zu öffnen.

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

    using UnityEngine;
    using UnityEngine.Windows.Speech;

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

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

Nun benötigen Sie die Methode, die die App verwendet, um die Sprachaufnahme zu starten und zu beenden, 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 anhält. 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.

Speichern Sie ihre Änderungen in Visual Studio , bevor Sie zu Unity zurückkehren.

Hinweis

An diesem Punkt wird ein Fehler im Konsolenbereich des Unity-Editors 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, dass Sie die LuisManager-Klasse erstellen, die den Aufruf des Azure LUIS-Diensts bewirkt.

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

Diese Klasse deserialisiert die JSON-Antwort und ruft die entsprechenden Methoden der Behaviors-Klasse auf, 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 die folgenden Namespaces am Anfang der Datei 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 (in derselben Skriptdatei über 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 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 in 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:

    private void Awake()
    {
        // allows this class instance to behave like a singleton
        instance = this;
    }

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

Nachdem der Wert der Absicht und der zugeordneten Entitäten ermittelt wurde, werden sie an den instance 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 ermittelt wurden, werden sie an die instance der Behaviors-Klasse übergeben, um sie in den Aktionen zu verwenden.

    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 Start() - und Update()- Methoden, da diese von dieser Klasse nicht verwendet werden.

Speichern Sie ihre Änderungen in Visual Studio , bevor Sie zu Unity zurückkehren.

Hinweis

An diesem Punkt werden mehrere Fehler im Konsolenbereich des Unity-Editors angezeigt. Dies liegt daran, dass der Code auf die Behaviors-Klasse verweist, die Sie im nächsten Kapitel erstellen werden.

Kapitel 7: Erstellen der Behaviors-Klasse

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 Verhalten.
Doppelklicken Sie auf das Skript, um es mit Visual Studio zu öffnen.

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

    void Awake()
    {
        // allows this class instance to behave like a singleton
        instance = this;
    }

Die folgenden Methoden werden von der LuisManager-Klasse aufgerufen (die Sie zuvor erstellt haben), um zu bestimmen, welches Objekt das Ziel der Abfrage ist, und dann die entsprechende Aktion auszulösen.

    /// <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, welches der GameObjects das Ziel der aktuellen Absicht ist. Bei dieser Methode wird das Ziel standardmäßig auf das GameObject festgelegt, das "angezeigt" wird, wenn in den Entitäten kein explizites Ziel 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 Start() - und Update()- Methoden, da diese von dieser Klasse nicht verwendet werden.

Speichern Sie ihre Änderungen in Visual Studio , 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;
            }
        }
    }

Speichern Sie ihre Änderungen in Visual Studio , 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 erstellt haben, aus dem Ordner Skripts 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 angefügte Skript zu sehen, und Sie werden feststellen, dass in jedem Skript Parameter vorhanden sind, die noch festgelegt werden müssen.
Befolgen Sie die folgenden Anweisungen, um diese Parameter richtig festzulegen:
1. MicrophoneManager:
  - Ziehen Sie aus dem Hierarchiebereich das Diktattext-Objekt in das Feld Diktattextparameterwert .
2. Verhalten im Hierarchiebereich:
  - Ziehen Sie das Sphere-Objekt in das Feld Sphere-Referenzziel .
  - Ziehen Sie den Zylinder in das Feld Zylinderreferenzziel .
  - Ziehen Sie den Cube in das Feld Cube-Verweisziel .
3. Anvisieren:
  - Legen Sie den maximalen Abstand des Anvisierens auf 300 fest (sofern noch nicht geschehen).
Das Ergebnis sollte wie in der folgenden Abbildung aussehen:

Kapitel 10 – Testen im Unity-Editor

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

Stellen Sie Folgendes sicher:

Alle Skripts sind an das Hauptkameraobjekt angefügt.
Alle Felder im Hauptkamerainspektorbereich sind ordnungsgemäß zugewiesen.

Klicken Sie im Unity-Editor auf die Schaltfläche Wiedergabe. 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 beim Ändern des Standardaudiogeräts angezeigt wird, funktioniert die Szene möglicherweise nicht wie erwartet. Dies liegt an der Art und Weise, wie das Mixed Reality-Portal mit integrierten Mikrofonen für Headsets umgeht, die diese haben. 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>.
Aktivieren Sie das Kontrollkästchen Unity C#-Projekte (nützlich zum Anzeigen und Debuggen Ihres Codes nach der Erstellung des UWP-Projekts).
Klicken Sie auf Offene Szenen hinzufügen und dann auf Erstellen.
Sie werden aufgefordert, den Ordner auszuwählen, in dem Sie die Projektmappe erstellen möchten.
Erstellen Sie einen BUILDS-Ordner , und erstellen Sie in diesem Ordner einen weiteren Ordner mit einem geeigneten Namen Ihrer Wahl.
Klicken Sie auf Ordner auswählen , um mit dem Build an diesem Speicherort zu beginnen.
Sobald Unity die Erstellung 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 auf der Lösungsplattformx86, Lokaler Computer aus.
Wählen Sie in der Projektmappenkonfigurationdebuggen 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 die folgenden Schritte ausführen:
- Kennen Sie die IP-Adresse Ihrer HoloLens, die sie im Einstellungsnetzwerk > & Internet > Wi-Fi > Erweiterten Optionen finden. Die IPv4 ist die Adresse, die Sie verwenden sollten.
- Stellen Sie sicher , dass der Entwicklermodusaktiviert ist. finden Sie unter Einstellungen > Update & Sicherheit > für Entwickler.
Navigieren 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, bereit für den Start!
Nach dem Starten fordert die App Sie auf, den Zugriff auf das Mikrofon zu autorisieren. Verwenden Sie die Motion Controller, die Spracheingabe oder die Tastatur , um die Ja-Taste zu drücken.

Kapitel 12: Verbessern des LUIS-Diensts

Wichtig

Dieses Kapitel ist unglaublich wichtig und muss möglicherweise mehrmals durchlaufen werden, da es die Genauigkeit Ihres LUIS-Diensts verbessert: Stellen Sie sicher, dass Sie diesen Vorgang abschließen.

Um das von LUIS bereitgestellte Verständnisniveau zu verbessern, müssen Sie neue Äußerungen erfassen und zum erneuten Trainieren Ihrer LUIS-App verwenden.

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

Nachdem Sie Ihre Anwendung einige Male verwendet haben, wird alles, was Sie gesagt haben, von LUIS gesammelt und im LUIS-PORTAL verfügbar.

Navigieren Sie über diesen LINK zu Ihrer Portalanwendung, 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 .
Es wird eine Liste der Äußerungen angezeigt, die von Ihrer Mixed Reality-Anwendung an LUIS gesendet wurden.

Sie werden einige hervorgehobene Entitäten bemerken.

Indem Sie mit dem Mauszeiger auf jedes hervorgehobene Wort zeigen, können Sie jede Äußerung überprüfen und bestimmen, welche Entität richtig erkannt wurde, welche Entitäten falsch sind und welche Entitäten übersehen werden.

Im obigen Beispiel wurde festgestellt, dass das Wort "spear" als Ziel hervorgehoben wurde. Daher musste der Fehler korrigiert werden, indem Sie mit der Maus auf das Wort zeigen und auf Bezeichnung entfernen klicken.

Überprüfen von Äußerungen Beschriftungsbild entfernen

Wenn Sie Äußerungen finden, die völlig falsch sind, können Sie sie mit der Schaltfläche Löschen auf der rechten Seite des Bildschirms löschen.
Wenn Sie der Meinung sind, dass LUIS die Äußerung richtig interpretiert hat, können Sie deren 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 das Verständnis Ihrer Anwendung zu verbessern.

Viel Spaß!

Ihre fertige integrierte LUIS-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 zu reagieren.

Lab-Ergebnis

Zusatzübungen

Übung 1

Wenn Sie diese Anwendung verwenden, stellen Sie möglicherweise fest, dass es dies tun wird, wenn Sie das Floor-Objekt betrachten und bitten, seine Farbe zu ändern. Können Sie herausfinden, wie Sie verhindern können, dass Ihre Anwendung die Farbe "Floor" ändert?

Übung 2

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

HoloLens (1. Generation) und Azure 303: Natural Language Understanding (LUIS)

Geräteunterstützung

Voraussetzungen

Vorbereitung

Kapitel 1: Einrichten des Azure-Portals

Kapitel 2 – Das Language Understanding Portal

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 Behaviors-Klasse

Kapitel 8: Erstellen der Gaze-Klasse

Kapitel 9 – Abschließen der Szeneneinrichtung

Kapitel 10 – Testen im Unity-Editor

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

Kapitel 12: Verbessern des LUIS-Diensts

Ihre fertige integrierte LUIS-Anwendung

Zusatzübungen

Übung 1

Übung 2

Zusätzliche Ressourcen