HoloLens (1e generatie) en Azure 303: Natural Language Understanding (LUIS)
Notitie
De Mixed Reality Academy-zelfstudies zijn ontworpen met HoloLens (1e generatie) en Mixed Reality Immersive Headsets in gedachten. Daarom vinden we het belangrijk om deze zelfstudies te behouden voor ontwikkelaars die nog steeds op zoek zijn naar richtlijnen bij het ontwikkelen voor die apparaten. Deze zelfstudies worden niet bijgewerkt met de nieuwste toolsets of interacties die worden gebruikt voor HoloLens 2. Ze blijven behouden om door te gaan met het werken op de ondersteunde apparaten. Er is een nieuwe reeks zelfstudies die in de toekomst zullen worden gepost en die laten zien hoe u zich ontwikkelt voor HoloLens 2. Deze kennisgeving wordt bijgewerkt met een koppeling naar deze zelfstudies wanneer ze worden gepost.
In deze cursus leert u hoe u Language Understanding integreert in een mixed reality-toepassing met behulp van Azure Cognitive Services, met de Language Understanding-API.
Language Understanding (LUIS) is een Microsoft Azure-service, die toepassingen de mogelijkheid biedt om betekenis te geven uit gebruikersinvoer, bijvoorbeeld door te extraheren wat een persoon mogelijk wil, in hun eigen woorden. Dit wordt bereikt via machine learning, die de invoerinformatie begrijpt en leert en vervolgens kan antwoorden met gedetailleerde, relevante informatie. Ga naar de pagina Azure Language Understanding (LUIS) voor meer informatie.
Nadat u deze cursus hebt voltooid, hebt u een mixed reality immersive headset-toepassing die het volgende kan doen:
- Leg spraak van gebruikersinvoer vast met behulp van de microfoon die is gekoppeld aan de insluitende headset.
- Verzend de vastgelegde dicteerfunctie de Azure Language Understanding Intelligent Service (LUIS).
- Luis-extract betekenis hebben van de verzendgegevens, die worden geanalyseerd en proberen de intentie van de aanvraag van de gebruiker te bepalen, wordt gedaan.
Ontwikkeling omvat het maken van een app waarin de gebruiker spraak en/of ga kan gebruiken om de grootte en de kleur van de objecten in de scène te wijzigen. Het gebruik van bewegingscontrollers wordt niet behandeld.
In uw toepassing is het aan u om te bepalen hoe u de resultaten integreert met uw ontwerp. Deze cursus is ontworpen om u te leren hoe u een Azure-service integreert met uw Unity-project. Het is uw taak om de kennis die u uit deze cursus krijgt te gebruiken om uw mixed reality-toepassing te verbeteren.
Wees bereid om LUIS meerdere keren te trainen, dat wordt behandeld in hoofdstuk 12. U krijgt betere resultaten hoe vaker LUIS is getraind.
Ondersteuning voor apparaten
| Cursus | HoloLens | Insluitende headsets |
|---|---|---|
| MR en Azure 303: Natural Language Understanding (LUIS) | ✔️ | ✔️ |
Notitie
Hoewel deze cursus voornamelijk gericht is op Windows Mixed Reality immersive headsets (VR), kunt u ook toepassen wat u in deze cursus leert op Microsoft HoloLens. Terwijl u de cursus volgt, ziet u notities over de wijzigingen die u mogelijk moet toepassen om HoloLens te ondersteunen. Wanneer u HoloLens gebruikt, ziet u mogelijk echo tijdens spraakopname.
Vereisten
Notitie
Deze zelfstudie is ontworpen voor ontwikkelaars die basiservaring hebben met Unity en C#. Houd er ook rekening mee dat de vereisten en schriftelijke instructies in dit document staan voor wat is getest en geverifieerd op het moment van schrijven (mei 2018). U kunt de nieuwste software gebruiken, zoals vermeld in het artikel over de installatie van de hulpprogramma's , hoewel er niet van wordt uitgegaan dat de informatie in deze cursus perfect overeenkomt met wat u vindt in nieuwere software dan hieronder wordt vermeld.
Voor deze cursus raden we de volgende hardware en software aan:
- Een ontwikkel-pc, compatibel met Windows Mixed Reality voor insluitende headsetontwikkeling (VR)
- Windows 10 Fall Creators Update (of hoger) waarvoor de ontwikkelaarsmodus is ingeschakeld
- De nieuwste Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Een Windows Mixed Reality immersive (VR)-headset of Microsoft HoloLens waarvoor de ontwikkelaarsmodus is ingeschakeld
- Een set hoofdtelefoons met een ingebouwde microfoon (als de headset geen ingebouwde microfoon en luidsprekers heeft)
- Internettoegang voor Het instellen van Azure en het ophalen van LUIS
Voordat u begint
Om problemen met het bouwen van dit project te voorkomen, wordt u sterk aangeraden het project te maken dat in deze zelfstudie wordt genoemd in een hoofdmap of in een near-rootmap (lange mappaden kunnen problemen veroorzaken tijdens de build).
Als u wilt dat uw computer Dicteren inschakelt, gaat u naar Privacyspraak > voor Windows-instellingen>, handschrift en typen en drukt u op de knop Spraakservices inschakelen en suggesties typen.
Met de code in deze zelfstudie kunt u opnemen vanuit het standaardmicrofoonapparaat dat is ingesteld op uw computer. Zorg ervoor dat het standaardmicrofoonapparaat is ingesteld als het apparaat dat u wilt gebruiken om uw stem vast te leggen.
Als uw headset een ingebouwde microfoon heeft, controleert u of de optie 'Wanneer ik mijn headset draag, schakel ik over naar microfoon van headset' is ingeschakeld in de instellingen van de Mixed Reality-portal .
Hoofdstuk 1: Azure Portal instellen
Als u de Language Understanding-service in Azure wilt gebruiken, moet u een exemplaar van de service configureren dat beschikbaar moet worden gemaakt voor uw toepassing.
Meld u aan bij de Azure Portal.
Notitie
Als u nog geen Azure-account hebt, moet u er een maken. Als u deze zelfstudie volgt in een leslokaal- of labsituatie, vraagt u uw docent of een van de proctors voor hulp bij het instellen van uw nieuwe account.
Zodra u bent aangemeld, klikt u op Nieuw in de linkerbovenhoek en zoekt u Language Understanding en klikt u op Enter.
Notitie
Het woord Nieuw is mogelijk vervangen door Een resource maken in nieuwere portals.
De nieuwe pagina rechts geeft een beschrijving van de Language Understanding-service. Selecteer linksonder op deze pagina de knop Maken om een exemplaar van deze service te maken.
Zodra u op Maken hebt geklikt:
Voeg de gewenste naam in voor dit service-exemplaar.
Selecteer een abonnement.
Selecteer de prijscategorie die voor u geschikt is. Als dit de eerste keer is dat u een LUIS-service maakt, moet er een gratis laag (met de naam F0) voor u beschikbaar zijn. De gratis toewijzing moet meer dan voldoende zijn voor deze cursus.
Kies een resourcegroep of maak een nieuwe. Een resourcegroep biedt een manier om de toegang te bewaken, te beheren, facturering in te richten en te beheren voor een verzameling Azure-assets. Het wordt aanbevolen om alle Azure-services die zijn gekoppeld aan één project (zoals deze cursussen) onder een gemeenschappelijke resourcegroep te houden.
Als u meer wilt weten over Azure-resourcegroepen, gaat u naar het artikel over de resourcegroep.
Bepaal de locatie voor uw resourcegroep (als u een nieuwe resourcegroep maakt). De locatie zou zich idealiter in de regio bevinden waar de toepassing zou worden uitgevoerd. Sommige Azure-assets zijn alleen beschikbaar in bepaalde regio's.
U moet ook bevestigen dat u de voorwaarden hebt begrepen die op deze Service zijn toegepast.
Selecteer Maken.
Nadat u op Maken hebt geklikt, moet u wachten totdat de service is gemaakt. Dit kan een minuut duren.
Er wordt een melding weergegeven in de portal zodra het service-exemplaar is gemaakt.
Klik op de melding om uw nieuwe service-exemplaar te verkennen.
Klik op de knop Ga naar de resource in de melding om uw nieuwe service-exemplaar te verkennen. U wordt naar uw nieuwe LUIS-service-exemplaar gebracht.
In deze zelfstudie moet uw toepassing aanroepen doen naar uw service, wat wordt gedaan met behulp van de abonnementssleutel van uw service.
Ga op de pagina Snel starten van uw LUIS API-service naar de eerste stap, pak uw sleutels en klik op Sleutels (u kunt dit ook bereiken door te klikken op de blauwe hyperlinksleutels, die zich in het navigatiemenu van de services bevinden, aangeduid door het sleutelpictogram). Hiermee worden uw servicesleutels weergegeven.
Maak een kopie van een van de weergegeven sleutels, omdat u dit later in uw project nodig hebt.
Klik op de pagina Service op Language Understanding Portal om te worden omgeleid naar de webpagina die u gaat gebruiken om uw nieuwe service te maken in de LUIS-app.
Hoofdstuk 2 : De Language Understanding-portal
In deze sectie leert u hoe u een LUIS-app maakt in de LUIS-portal.
Belangrijk
Houd er rekening mee dat het instellen van de entiteiten, intenties en uitingen in dit hoofdstuk alleen de eerste stap is bij het bouwen van uw LUIS-service: u moet de service ook meerdere keren opnieuw trainen, zodat u deze nauwkeuriger kunt maken. Het opnieuw trainen van uw service wordt behandeld in het laatste hoofdstuk van deze cursus, dus zorg ervoor dat u deze voltooit.
Wanneer u de Language Understanding-portal hebt bereikt, moet u zich mogelijk aanmelden als u nog niet bent, met dezelfde referenties als uw Azure-portal.
Als dit de eerste keer is dat u LUIS gebruikt, moet u omlaag schuiven naar de onderkant van de welkomstpagina om de knop LUIS-app maken te zoeken en erop te klikken.
Zodra u bent aangemeld, klikt u op Mijn apps (als u zich momenteel niet in die sectie bevindt). U kunt vervolgens klikken op Nieuwe app maken.
Geef uw app een naam.
Als uw app een andere taal moet begrijpen dan Engels, moet u de Cultuur wijzigen in de juiste taal.
Hier kunt u ook een beschrijving van uw nieuwe LUIS-app toevoegen.
Wanneer u op Gereed drukt, voert u de pagina Build van uw nieuwe LUIS-toepassing in.
Er zijn hier enkele belangrijke concepten die u moet begrijpen:
- Intentie, vertegenwoordigt de methode die wordt aangeroepen na een query van de gebruiker. Een INTENT kan een of meer ENTITEITEN hebben.
- Entiteit is een onderdeel van de query die informatie beschrijft die relevant is voor de INTENTIE.
- Uitingen zijn voorbeelden van query's die door de ontwikkelaar worden geleverd, die LUIS zal gebruiken om zichzelf te trainen.
Als deze concepten niet perfect duidelijk zijn, maakt u zich geen zorgen, want deze cursus zal ze verder verduidelijken in dit hoofdstuk.
U begint met het maken van de entiteiten die nodig zijn om deze cursus te bouwen.
Klik aan de linkerkant van de pagina op Entiteiten en klik vervolgens op Nieuwe entiteit maken.
Roep de nieuwe entiteitskleur aan, stel het type in op Eenvoudig en druk vervolgens op Gereed.
Herhaal dit proces om drie (3) eenvoudigere entiteiten met de naam te maken:
- upsize
- Krimpen
- doel
Het resultaat moet eruitzien zoals in de onderstaande afbeelding:
Op dit moment kunt u beginnen met het maken van intenties.
Waarschuwing
Verwijder de intentie None niet.
Klik aan de linkerkant van de pagina op Intenties en klik vervolgens op Nieuwe intentie maken.
Roep de nieuwe Intent ChangeObjectColor aan.
Belangrijk
Deze intentienaam wordt later in deze cursus gebruikt in de code, dus voor de beste resultaten gebruikt u deze naam precies zoals opgegeven.
Zodra u de naam bevestigt, wordt u omgeleid naar de pagina Intenties.
U ziet dat er een tekstvak is waarin u wordt gevraagd om 5 of meer verschillende utterances te typen.
Notitie
LUIS converteert alle utterances naar kleine letters.
- Voeg de volgende uiting in het bovenste tekstvak (momenteel met het teksttype ongeveer 5 voorbeelden... ) in en druk op Enter:
The color of the cylinder must be red
U ziet dat de nieuwe uiting wordt weergegeven in een lijst eronder.
Voeg na hetzelfde proces de volgende zes (6) uitingen in:
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
Voor elke uiting die u hebt gemaakt, moet u bepalen welke woorden door LUIS moeten worden gebruikt als entiteiten. In dit voorbeeld moet u alle kleuren labelen als een kleurenentiteit en alle mogelijke verwijzingen naar een doelentiteit als doelentiteit.
Als u dit wilt doen, klikt u op de woord cilinder in de eerste uiting en selecteert u het doel.
Klik nu op het woord rood in de eerste uiting en selecteer kleur.
Label ook de volgende regel, waarbij kubus een doel moet zijn en zwart een kleur moet zijn. U ziet ook het gebruik van de woorden 'this', 'it' en 'this object', die we bieden, zodat er ook niet-specifieke doeltypen beschikbaar zijn.
Herhaal het bovenstaande proces totdat alle uitingen de entiteiten hebben gelabeld. Zie de onderstaande afbeelding als u hulp nodig hebt.
Tip
Wanneer u woorden selecteert om ze als entiteiten te labelen:
- Klik voor enkele woorden op de woorden.
- Voor een set van twee of meer woorden klikt u aan het begin en vervolgens aan het einde van de set.
Notitie
U kunt de wisselknop Tokensweergave gebruiken om te schakelen tussen entiteiten/tokens weergeven!
De resultaten moeten worden weergegeven in de onderstaande afbeeldingen, met de weergave Entiteiten/Tokens:
Druk op dit punt op de knop Trainen rechtsboven op de pagina en wacht totdat de kleine ronde indicator erop groen wordt. Dit geeft aan dat LUIS is getraind om deze intentie te herkennen.
Maak als oefening een nieuwe intentie met de naam ChangeObjectSize, met behulp van het doel entiteiten, upsize en downsize.
Voeg na hetzelfde proces als de vorige intentie de volgende acht (8) utterances in om de grootte te wijzigen:
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 objectHet resultaat moet er als volgt uitzien in de onderstaande afbeelding:
Zodra beide intenties, ChangeObjectColor en ChangeObjectSize zijn gemaakt en getraind, klikt u op de knop PUBLICEREN boven aan de pagina.
Op de pagina Publiceren voltooit en publiceert u uw LUIS-app, zodat deze toegankelijk is voor uw code.
Stel de vervolgkeuzelijst Publiceren naar in als Productie.
Stel de tijdzone in op uw tijdzone.
Schakel het selectievakje Alle voorspelde intentiescores in.
Klik op Publiceren naar productiesite.
In de sectie Resources en Sleutels:
- Selecteer de regio die u hebt ingesteld voor het service-exemplaar in Azure Portal.
- Hieronder ziet u een Starter_Key element.
- Klik op Sleutel toevoegen en voeg de sleutel in die u hebt verkregen in Azure Portal toen u uw service-exemplaar maakte. Als uw Azure en de LUIS-portal zijn aangemeld bij dezelfde gebruiker, krijgt u vervolgkeuzelijsten voor tenantnaam, abonnementsnaam en de sleutel die u wilt gebruiken (heeft dezelfde naam als u eerder hebt opgegeven in Azure Portal.
Belangrijk
Neem onder Eindpunt een kopie van het eindpunt dat overeenkomt met de sleutel die u hebt ingevoegd. U gebruikt het binnenkort in uw code.
Hoofdstuk 3 : Het Unity-project instellen
Hier volgt een typische opzet voor het ontwikkelen met mixed reality en is als zodanig een goede sjabloon voor andere projecten.
Open Unity en klik op Nieuw.
U moet nu een Unity-projectnaam opgeven, MR_LUIS invoegen. Zorg ervoor dat het projecttype is ingesteld op 3D. Stel de locatie in op een locatie die geschikt is voor u (vergeet niet, dichter bij hoofdmappen is beter). Klik vervolgens op Project maken.
Als Unity is geopend, is het de moeite waard om te controleren of de standaardscripteditor is ingesteld op Visual Studio. Ga naar Voorkeuren bewerken > en navigeer vervolgens vanuit het nieuwe venster naar Externe hulpprogramma's. Wijzig de externe scripteditor in Visual Studio 2017. Sluit het venster Voorkeuren .
Ga vervolgens naar > Instellingen voor bestandsbuild en schakel het platform over naar Universeel Windows-platform door op de knop Platform wisselen te klikken.
Ga naar Instellingen voor bestandsbuild > en zorg ervoor dat:
Doelapparaat is ingesteld op Elk apparaat
Voor de Microsoft HoloLens stelt u Doelapparaat in op HoloLens.
Buildtype is ingesteld op D3D
SDK is ingesteld op Laatst geïnstalleerd
Visual Studio-versie is ingesteld op Meest recent geïnstalleerd
Bouwen en uitvoeren is ingesteld op lokale computer
Sla de scène op en voeg deze toe aan de build.
Doe dit door Open Scènes toevoegen te selecteren. Er wordt een venster voor opslaan weergegeven.
Maak hiervoor een nieuwe map, en voor elke toekomst scène, selecteer vervolgens de knop Nieuwe map om een nieuwe map te maken, geef deze de naam Scènes.
Open de zojuist gemaakte map Scènes en druk vervolgens in het tekstvak Bestandsnaam: tekstveld MR_LuisScene en druk op Opslaan.
De overige instellingen, in Build-instellingen, moeten voorlopig standaard blijven staan.
Klik in het venster Build-instellingen op de knop Spelerinstellingen . Hiermee opent u het gerelateerde deelvenster in de ruimte waar de Inspector zich bevindt.
In dit deelvenster moeten enkele instellingen worden geverifieerd:
Op het tabblad Overige instellingen :
De runtimeversie van scripting moet stabiel zijn (equivalent van.NET 3.5).
Back-end voor scripts moet .NET zijn
API-compatibiliteitsniveau moet .NET 4.6 zijn
Schakel op het tabblad Publicatie-instellingen onder Mogelijkheden het volgende in:
InternetClient
Microfoon
Schakel verderop in het deelvenster in XR-instellingen (hieronder Publicatie-instellingen) het selectievakje Virtual Reality Ondersteund in, zorg ervoor dat de Windows Mixed Reality SDK is toegevoegd.
Terug in Build Settings Unity C# Projects wordt niet meer grijs weergegeven. Schakel het selectievakje naast dit selectievakje in.
Sluit het venster Build Settings.
Sla uw scène en project op (FILE > SAVE SCENE/ FILE > SAVE PROJECT).
Hoofdstuk 4 – De scène maken
Belangrijk
Als u het Unity Set up-onderdeel van deze cursus wilt overslaan en direct in code wilt doorgaan, kunt u deze .unitypackage downloaden, importeren in uw project als een aangepast pakket en vervolgens doorgaan vanaf hoofdstuk 5.
Klik met de rechtermuisknop in een leeg gebied van het deelvenster Hiërarchie, onder 3D-object, en voeg een vlak toe.
Houd er rekening mee dat wanneer u opnieuw met de rechtermuisknop in de hiërarchie klikt om meer objecten te maken, als u nog steeds het laatste object hebt geselecteerd, het geselecteerde object het bovenliggende object van het nieuwe object is. Vermijd dit klikken met de linkermuisknop in een lege ruimte in de hiërarchie en klik vervolgens met de rechtermuisknop.
Herhaal de bovenstaande procedure om de volgende objecten toe te voegen:
- Bol
- Cilinder
- Kubus
- 3D-tekst
De resulterende scènehiërarchie moet er als volgt uitzien in de onderstaande afbeelding:
Klik met de linkermuisknop op de hoofdcamera om deze te selecteren, kijk naar het Inspector Panel dat u het Camera-object met alle onderdelen ziet.
Klik op de knop Onderdeel toevoegen aan de onderkant van het inspectorpaneel.
Zoek naar het onderdeel audiobron, zoals hierboven wordt weergegeven.
Zorg er ook voor dat het onderdeel Transformeren van de hoofdcamera is ingesteld op (0,0,0), dit kan worden gedaan door op het tandwielpictogram naast het onderdeel Transformatie van de camera te drukken en Reset te selecteren. Het onderdeel Transformeren moet er dan als volgt uitzien:
- De positie is ingesteld op 0, 0, 0.
- Draaiing is ingesteld op 0, 0, 0.
Notitie
Voor de Microsoft HoloLens moet u ook het volgende wijzigen, dat deel uitmaakt van het cameraonderdeel , dat zich op uw hoofdcamera bevindt:
- Markeringen wissen: effen kleur.
- Achtergrond 'Zwart, Alfa 0' – Hexkleur: #000000000.
Klik met de linkermuisknop op het vliegtuig om het te selecteren. Stel in het Inspector-deelvenster het onderdeel Transformeren in met de volgende waarden:
X-as Y-as Z-as 0 -1 0 Klik met de linkermuisknop op de Bol om deze te selecteren. Stel in het Inspector-deelvenster het onderdeel Transformeren in met de volgende waarden:
X-as Y-as Z-as 2 1 2 Klik met de linkermuisknop op de cilinder om deze te selecteren. Stel in het Inspector-deelvenster het onderdeel Transformeren in met de volgende waarden:
X-as Y-as Z-as -2 1 2 Klik met de linkermuisknop op de kubus om deze te selecteren. Stel in het Inspector-deelvenster het onderdeel Transformeren in met de volgende waarden:
Transformeren - positie
| X | Y | Z |
|---|---|---|
| 0 | 1 | 4 |
Transformatie - Rotatie
| X | Y | Z |
|---|---|---|
| 45 | 45 | 0 |
- Klik met de linkermuisknop op het object Nieuwe tekst om het te selecteren. Stel in het Inspector-deelvenster het onderdeel Transformeren in met de volgende waarden:
Transformeren - positie
| X | Y | Z |
|---|---|---|
| -2 | 6 | 9 |
Transformeren - Schalen
| X | Y | Z |
|---|---|---|
| 0,1 | 0,1 | 0,1 |
Wijzig de tekengrootte in het text mesh-onderdeel in 50.
Wijzig de naam van het Text Mesh-object in Dictation Text.
De structuur van het deelvenster Hiërarchie moet er nu als volgt uitzien:
De laatste scène moet eruitzien zoals in de onderstaande afbeelding:
Hoofdstuk 5 : de klasse MicrophoneManager maken
Het eerste script dat u gaat maken, is de klasse MicrophoneManager . Hierna maakt u de LuisManager, de klasse Behaviors en ten slotte de gazeklasse (u kunt dit nu allemaal maken, hoewel dit wordt behandeld wanneer u elk hoofdstuk bereikt).
De klasse MicrophoneManager is verantwoordelijk voor:
- Detecteren van het opnameapparaat dat is gekoppeld aan de headset of machine (afhankelijk van de standaardinstelling).
- Leg de audio (spraak) vast en gebruik dicteren om het op te slaan als een tekenreeks.
- Zodra de stem is onderbroken, dient u de dicteerfunctie in bij de klasse LuisManager .
Ga als volgt te werk om deze klasse te maken:
Klik met de rechtermuisknop in het deelvenster Project, Map maken>. Roep de mapscripts aan.
Dubbelklik op de map Scripts om deze te openen. Klik vervolgens in die map met de rechtermuisknop op C#-script maken>. Geef het script de naam MicrophoneManager.
Dubbelklik op MicrophoneManager om deze te openen met Visual Studio.
Voeg de volgende naamruimten toe aan het begin van het bestand:
using UnityEngine; using UnityEngine.Windows.Speech;Voeg vervolgens de volgende variabelen toe in de klasse MicrophoneManager :
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 resultDe methoden Code for Awake() en Start() moeten nu worden toegevoegd. Deze worden aangeroepen wanneer de klasse wordt geïnitialiseerd:
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"); } }Nu hebt u de methode nodig die de app gebruikt om de spraakopname te starten en te stoppen en door te geven aan de LuisManager-klasse , die u binnenkort gaat bouwen.
/// <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..."); }Voeg een dicteerhandler toe die wordt aangeroepen wanneer de stem wordt onderbroken. Met deze methode wordt de dicteertekst doorgegeven aan de klasse LuisManager .
/// <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); }Belangrijk
Verwijder de methode Update() omdat deze klasse deze niet gebruikt.
Sla uw wijzigingen op in Visual Studio voordat u terugkeert naar Unity.
Notitie
Op dit moment ziet u een fout die wordt weergegeven in het consolepaneel van de Unity-editor. Dit komt doordat de code verwijst naar de LuisManager-klasse die u in het volgende hoofdstuk gaat maken.
Hoofdstuk 6: de LUISManager-klasse maken
Het is tijd om de LuisManager-klasse te maken, waarmee de Azure LUIS-service wordt aangeroepen.
Het doel van deze klasse is om de dicteertekst van de klasse MicrophoneManager te ontvangen en deze te verzenden naar de Azure Language Understanding-API die moet worden geanalyseerd.
Met deze klasse wordt het JSON-antwoord gedeserialiseerd en worden de juiste methoden van de klasse Behaviors aangeroepen om een actie te activeren.
Ga als volgt te werk om deze klasse te maken:
Dubbelklik op de map Scripts om deze te openen.
Klik met de rechtermuisknop in de map Scripts en klik op C#-script maken>. Geef het script de naam LuisManager.
Dubbelklik op het script om het te openen met Visual Studio.
Voeg de volgende naamruimten toe aan het begin van het bestand:
using System; using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using UnityEngine.Networking;U begint met het maken van drie klassen in de LuisManager-klasse (binnen hetzelfde scriptbestand, boven de Methode Start() die het gedeserialiseerde JSON-antwoord van Azure vertegenwoordigt.
[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; }Voeg vervolgens de volgende variabelen toe in de klasse LuisManager :
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";Zorg ervoor dat u uw LUIS-eindpunt nu plaatst (die u hebt via uw LUIS-portal).
Code voor de Awake() -methode moet nu worden toegevoegd. Deze methode wordt aangeroepen wanneer de klasse wordt geïnitialiseerd:
private void Awake() { // allows this class instance to behave like a singleton instance = this; }U hebt nu de methoden nodig die door deze toepassing worden gebruikt om de dicteerfunctie die is ontvangen van de klasse MicrophoneManager naar LUIS te verzenden en vervolgens het antwoord te ontvangen en deserialiseren.
Zodra de waarde van de intentie en de bijbehorende entiteiten is vastgesteld, worden ze doorgegeven aan het exemplaar van de klasse Gedragss om de beoogde actie te activeren.
/// <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; } }Maak een nieuwe methode met de naam AnalyseResponseElements() die de resulterende AnalysisQuery leest en de entiteiten bepaalt. Zodra deze entiteiten zijn vastgesteld, worden ze doorgegeven aan het exemplaar van de klasse Behaviors dat in de acties moet worden gebruikt.
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; } }Belangrijk
Verwijder de methoden Start() en Update() omdat deze klasse deze niet gebruikt.
Sla uw wijzigingen op in Visual Studio voordat u terugkeert naar Unity.
Notitie
Op dit moment ziet u verschillende fouten die worden weergegeven in het deelvenster van de Unity Editor-console. Dit komt doordat de code verwijst naar de klasse Behaviors die u in het volgende hoofdstuk gaat maken.
Hoofdstuk 7 – De gedragsklasse maken
De klasse Behaviors activeert de acties met behulp van de entiteiten van de klasse LuisManager .
Ga als volgt te werk om deze klasse te maken:
Dubbelklik op de map Scripts om deze te openen.
Klik met de rechtermuisknop in de map Scripts en klik op C#-script maken>. Noem het script Behaviors.
Dubbelklik op het script om het te openen met Visual Studio.
Voeg vervolgens de volgende variabelen toe in de klasse Behaviors :
public static Behaviours instance; // the following variables are references to possible targets public GameObject sphere; public GameObject cylinder; public GameObject cube; internal GameObject gazedTarget;Voeg de methodecode Awake() toe. Deze methode wordt aangeroepen wanneer de klasse wordt geïnitialiseerd:
void Awake() { // allows this class instance to behave like a singleton instance = this; }De volgende methoden worden aangeroepen door de LuisManager-klasse (die u eerder hebt gemaakt) om te bepalen welk object het doel van de query is en vervolgens de juiste actie activeert.
/// <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); }Voeg de methode FindTarget() toe om te bepalen welke van de GameObjects het doel is van de huidige intentie. Met deze methode wordt het doel standaard ingesteld op het GameObject dat wordt 'gazed' als er geen expliciet doel is gedefinieerd in de entiteiten.
/// <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; }Belangrijk
Verwijder de methoden Start() en Update() omdat deze klasse deze niet gebruikt.
Sla uw wijzigingen op in Visual Studio voordat u terugkeert naar Unity.
Hoofdstuk 8 – De klasse Gaze maken
De laatste klasse die u nodig hebt om deze app te voltooien, is de klasse Gaze . Met deze klasse wordt de verwijzing naar het GameObject bijgewerkt dat momenteel in de visuele focus van de gebruiker ligt.
Ga als volgt te werk om deze klasse te maken:
Dubbelklik op de map Scripts om deze te openen.
Klik met de rechtermuisknop in de map Scripts en klik op C#-script maken>. Geef het script de naam Gaze.
Dubbelklik op het script om het te openen met Visual Studio.
Voeg de volgende code in voor deze klasse:
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; } } }Sla uw wijzigingen op in Visual Studio voordat u terugkeert naar Unity.
Hoofdstuk 9: de installatie van de scène voltooien
Als u de installatie van de scène wilt voltooien, sleept u elk script dat u hebt gemaakt vanuit de map Scripts naar het object Hoofdcamera in het deelvenster Hiërarchie.
Selecteer de hoofdcamera en kijk naar het inspectorpaneel. U moet elk script kunnen zien dat u hebt gekoppeld en u zult merken dat er parameters zijn voor elk script dat nog moet worden ingesteld.
Volg deze instructies om deze parameters correct in te stellen:
MicrophoneManager:
- Sleep vanuit het deelvenster Hiërarchie het object Dictation Text naar het waardevak van de parameter Dictation Text.
Gedrag, vanuit het deelvenster Hiërarchie:
- Sleep het Sphere-object naar het doelvak van de Sphere-verwijzing .
- Sleep de cilinder naar het doelvak cilinderreferentie .
- Sleep de kubus naar het doelvak kubusreferentie .
Kijk:
- Stel de max.afstand van 300 in op 300 (als deze nog niet is).
Het resultaat moet eruitzien zoals in de onderstaande afbeelding:
Hoofdstuk 10 – Testen in de Unity Editor
Test of de scène-installatie correct is geïmplementeerd.
U moet het volgende hebben gedaan:
- Alle scripts zijn gekoppeld aan het object Main Camera .
- Alle velden in het configuratiescherm van de hoofdcamera zijn correct toegewezen.
Druk op de knop Afspelen in de Unity Editor. De app moet worden uitgevoerd binnen de aangesloten insluitende headset.
Probeer een paar uitingen, zoals:
make the cylinder red change the cube to yellow I want the sphere blue make this to green change it to whiteNotitie
Als er een fout wordt weergegeven in de Unity-console over het wijzigen van het standaardaudioapparaat, werkt de scène mogelijk niet zoals verwacht. Dit komt door de manier waarop de mixed reality-portal omgaat met ingebouwde microfoons voor headsets die deze hebben. Als u deze fout ziet, stopt u de scène en start u deze opnieuw en werkt alles zoals verwacht.
Hoofdstuk 11: de UWP-oplossing bouwen en sideloaden
Zodra u ervoor hebt gezorgd dat de toepassing in de Unity Editor werkt, kunt u bouwen en implementeren.
Ga als volgende te werk om te bouwen:
Sla de huidige scène op door op Bestand > opslaan te klikken.
Ga naar Instellingen voor het > maken van bestanden.
Schakel het vakje Unity C#-projecten in (handig voor het bekijken en opsporen van fouten in uw code zodra het UWP-project is gemaakt.
Klik op Open Scènes toevoegen en klik vervolgens op Bouwen.
U wordt gevraagd om de map te selecteren waarin u de oplossing wilt bouwen.
Maak een BUILDS-map en maak in die map een andere map met de juiste naam van uw keuze.
Klik op Map selecteren om de build op die locatie te starten.
Zodra Unity klaar is met het bouwen (het kan enige tijd duren), moet er een Bestandenverkenner venster worden geopend op de locatie van uw build.
Implementeren op lokale computer:
Open in Visual Studio het oplossingsbestand dat in het vorige hoofdstuk is gemaakt.
Selecteer x86 in het Solution Platform, Local Machine.
Selecteer foutopsporing in de oplossingsconfiguratie.
Voor de Microsoft HoloLens is het mogelijk gemakkelijker om dit in te stellen op Externe computer, zodat u niet aan uw computer bent gekoppeld. U moet echter ook het volgende doen:
- Ken het IP-adres van uw HoloLens, die u kunt vinden in de geavanceerde opties voor het instellingennetwerk > en internet-Wi-Fi > >. De IPv4 is het adres dat u moet gebruiken.
- Zorg ervoor dat de ontwikkelaarsmodus is ingeschakeld. Deze vindt u in Instellingen > bijwerken en beveiliging > voor ontwikkelaars.
Ga naar het menu Build en klik op Oplossing implementeren om de toepassing naar uw computer te sideloaden.
Uw app moet nu worden weergegeven in de lijst met geïnstalleerde apps, klaar om te worden gestart.
Zodra de app is gestart, wordt u gevraagd om toegang tot de microfoon te autoriseren. Gebruik de bewegingscontrollers of spraakinvoer of het toetsenbord om op de knop JA te drukken.
Hoofdstuk 12: uw LUIS-service verbeteren
Belangrijk
Dit hoofdstuk is ongelooflijk belangrijk en moet mogelijk meerdere keren worden herhaald, omdat het helpt de nauwkeurigheid van uw LUIS-service te verbeteren: zorg ervoor dat u dit voltooit.
Als u het begripsniveau van LUIS wilt verbeteren, moet u nieuwe uitingen vastleggen en gebruiken om uw LUIS-app opnieuw te trainen.
U hebt LUIS bijvoorbeeld getraind om inzicht te krijgen in 'Vergroten' en 'Upsize', maar wilt u niet dat uw app ook woorden begrijpt zoals 'Vergroten'?
Zodra u uw toepassing een paar keer hebt gebruikt, wordt alles wat u hebt gezegd verzameld door LUIS en beschikbaar in de LUIS-PORTAL.
Ga naar de portaltoepassing die deze KOPPELING volgt en meld u aan.
Zodra u bent aangemeld met uw MS-referenties, klikt u op uw app-naam.
Klik op de knop Eindpuntuitingen controleren aan de linkerkant van de pagina.
U ziet een lijst met de utterances die zijn verzonden naar LUIS door uw mixed reality-toepassing.
U ziet enkele gemarkeerde entiteiten.
Door de muisaanwijzer op elk gemarkeerd woord te bewegen, kunt u elke uiting controleren en bepalen welke entiteit correct is herkend, welke entiteiten onjuist zijn en welke entiteiten worden gemist.
In het bovenstaande voorbeeld is vastgesteld dat het woord 'spear' als doel is gemarkeerd, dus het is nodig om de fout te corrigeren. Dit wordt gedaan door met de muis over het woord te bewegen en op Label verwijderen te klikken.
Als u uitingen vindt die helemaal onjuist zijn, kunt u ze verwijderen met behulp van de knop Verwijderen aan de rechterkant van het scherm.
Of als u denkt dat LUIS de uiting correct heeft geïnterpreteerd, kunt u het begrip valideren met behulp van de knop Aan uitgelijnde intentie toevoegen.
Nadat u alle weergegeven utterances hebt gesorteerd, probeert u de pagina opnieuw te laden om te zien of er meer beschikbaar zijn.
Het is erg belangrijk om dit proces zo vaak mogelijk te herhalen om uw toepassingskennis te verbeteren.
Veel plezier!
Uw voltooide geïntegreerde LUIS-toepassing
Gefeliciteerd, u hebt een mixed reality-app gebouwd die gebruikmaakt van de Azure Language Understanding Intelligence Service, om inzicht te krijgen in wat een gebruiker zegt en om op die informatie te reageren.
Bonusoefeningen
Oefening 1
Tijdens het gebruik van deze toepassing merkt u misschien dat als u naar het object Floor kijkt en vraagt om de kleur te wijzigen, dit gebeurt. Kunt u instellen hoe u kunt voorkomen dat uw toepassing de vloerkleur wijzigt?
Oefening 2
Probeer de LUIS- en app-mogelijkheden uit te breiden en extra functionaliteit toe te voegen voor objecten in scènes; Als voorbeeld maakt u nieuwe objecten op het trefferpunt Gaze, afhankelijk van wat de gebruiker zegt en kunt u deze objecten vervolgens naast de huidige scèneobjecten gebruiken met de bestaande opdrachten.