HoloLens (eerste generatie) en Azure 303: Natural Language Understanding (LUIS)


Notitie

De Mixed Reality Academy-zelfstudies zijn ontworpen met HoloLens (eerste generatie) en Mixed Reality In immersive Headsets in gedachten. Daarom vinden we het belangrijk om deze zelfstudies te laten staan voor ontwikkelaars die nog op zoek zijn naar richtlijnen voor het ontwikkelen van deze apparaten. Deze zelfstudies worden niet bijgewerkt met de nieuwste toolsets of interacties die worden gebruikt voor HoloLens 2. Ze blijven behouden om te blijven werken op de ondersteunde apparaten. Er is een nieuwe reeks zelfstudies die in de toekomst worden geplaatst, waarin wordt gedemonstreerd hoe u ontwikkelt voor HoloLens 2. Deze kennisgeving wordt bijgewerkt met een koppeling naar deze zelfstudies wanneer ze worden geplaatst.


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.

Labresultaat

Language Understanding (LUIS) is een Microsoft Azure-service die toepassingen de mogelijkheid biedt om betekenis te geven aan gebruikersinvoer, bijvoorbeeld door in zijn eigen woorden uit te extraheren wat een persoon zou willen. Dit wordt bereikt door 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:

  1. Leg spraak voor gebruikersinvoer vast met behulp van de microfoon die is gekoppeld aan immersive headset.
  2. Verzend de vastgelegde dicteer de Azure Language Understanding Intelligent Service (LUIS).
  3. Laat LUIS betekenis extraheren uit de verzendgegevens, die worden geanalyseerd, en probeer de intentie van de aanvraag van de gebruiker te bepalen.

Ontwikkeling omvat het maken van een app waarbij de gebruiker spraak en/of staren kan gebruiken om de grootte en 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 weten 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 van deze cursus hebt op te doen, te gebruiken om uw mixed reality verbeteren.

Bereid u voor om LUIS meerdere keren te trainen. Dit wordt behandeld in hoofdstuk 12. U krijgt betere resultaten wanneer LUIS vaker is getraind.

Ondersteuning voor apparaten

Cursus HoloLens Immersive headsets
MR en Azure 303: Natural Language Understanding (LUIS) ✔️ ✔️

Notitie

Hoewel deze cursus voornamelijk gericht is op Windows Mixed Reality immersive (VR)-headsets, kunt u ook toepassen wat u in deze cursus leert om te Microsoft HoloLens. Terwijl u de cursus volgt, ziet u notities over wijzigingen die u mogelijk moet gebruiken om ondersteuning te HoloLens. Wanneer u HoloLens, ziet u mogelijk een 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 geschreven 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 Hulpprogramma's installeren, maar u mag er niet van uitgaan dat de informatie in deze cursus perfect aansluit bij wat u in nieuwere software vindt dan wat hieronder wordt vermeld.

Voor deze cursus raden we de volgende hardware en software aan:

Voordat u begint

  1. Om problemen met het bouwen van dit project te voorkomen, wordt u ten zeerste aangeraden om het project dat in deze zelfstudie wordt vermeld, te maken in een hoofdmap of in de buurt van de hoofdmap (lange mappaden kunnen problemen veroorzaken tijdens het bouwen).

  2. Als u wilt dat uw computer Dicteren kan inschakelen, gaat u naar Windows Instellingen > Privacy > Speech, & Typen indrukken en op de knop Spraakservices inschakelen en suggesties typen.

  3. Met de code in deze zelfstudie kunt u opnemen vanuit de standaardmicrofoonapparaat die 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.

  4. Als uw headset een ingebouwde microfoon heeft, moet u ervoor zorgen dat de optie 'Wanneer ik mijn headset draag, overschakelt naar headsetmicrofoon' is ingeschakeld in Mixed Reality-portal instellingen.

    Een immersive headset

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 gesteld aan uw toepassing.

  1. Meld u aan bij 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 om hulp bij het instellen van uw nieuwe account.

  2. Wanneer u bent aangemeld, klikt u op Nieuw in de linkerbovenhoek en zoekt u naar Language Understanding en klikt u op Enter.

    LUIS-resources maken

    Notitie

    Het woord Nieuw is mogelijk vervangen door Een resource maken in nieuwere portals.

  3. De nieuwe pagina aan de rechterkant geeft een beschrijving van de Language Understanding service. Selecteer linksonder op deze pagina de knop Maken om een exemplaar van deze service te maken.

    Luis-service maken - juridische kennisgeving

  4. Nadat u op Maken hebt geklikt:

    1. Voeg de gewenste Naam in voor dit service-exemplaar.

    2. Selecteer een Abonnement.

    3. Selecteer de prijscategorie die geschikt is voor u. 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.

    4. Kies een resourcegroep of maak een nieuwe. Een resourcegroep biedt een manier om de toegang te bewaken, te beheren, de facturering voor een verzameling Azure-assets in terichten en te beheren. Het is raadzaam om alle Azure-services die zijn gekoppeld aan één project (bijvoorbeeld deze cursussen) onder een gemeenschappelijke resourcegroep te houden.

      Als u meer wilt weten over Azure-resourcegroepen, raadpleegt u het artikel over de resourcegroep.

    5. Bepaal de locatie voor uw resourcegroep (als u een nieuwe resourcegroep maakt). De locatie bevindt zich idealiter in de regio waar de toepassing wordt uitgevoerd. Sommige Azure-assets zijn alleen beschikbaar in bepaalde regio's.

    6. U moet ook bevestigen dat u de voorwaarden hebt begrepen die op deze service zijn toegepast.

    7. Selecteer Maken.

      LUIS-service maken - gebruikersinvoer

  5. Nadat u op Maken hebt geklikt, moet u wachten tot de service is gemaakt. Dit kan een minuut duren.

  6. Er wordt een melding weergegeven in de portal zodra het service-exemplaar is gemaakt.

    Nieuwe azure-meldingsafbeelding

  7. Klik op de melding om uw nieuwe service-exemplaar te verkennen.

    Melding dat de resource is gemaakt

  8. Klik op de knop Ga naar resource in de melding om uw nieuwe service-exemplaar te verkennen. U wordt naar uw nieuwe LUIS-service-exemplaar overgebracht.

    Toegang tot LUIS-sleutels

  9. In deze zelfstudie moet uw toepassing uw service aanroepen. Dit wordt gedaan met behulp van de abonnementssleutel van uw service.

  10. 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 hyperlink Sleutels, die zich in het navigatiemenu van de services bevindt, aangeduid met het sleutelpictogram). Hiermee worden uw servicesleutels bekend.

  11. Maak een kopie van een van de weergegeven sleutels, want u hebt deze later in uw project nodig.

  12. 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 slechts de eerste stap is bij het bouwen van uw LUIS-service: u moet de service ook meerdere keren opnieuw trainen, zodat deze nauwkeuriger wordt. Uw service opnieuw trainen wordt behandeld in het laatste hoofdstuk van deze cursus, dus zorg ervoor dat u deze voltooit.

  1. Wanneer u de Language Understanding portal bereikt, moet u zich mogelijk aanmelden, als u dat nog niet hebt gedaan, met dezelfde referenties als uw Azure Portal.

    LUIS-aanmeldingspagina

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

    Pagina LUIS-app maken

  3. Wanneer u bent aangemeld, klikt u Mijn apps (als u zich momenteel niet in die sectie hebt). Klik vervolgens op Nieuwe app maken.

    LUIS - afbeelding van mijn apps

  4. Geef uw app een naam.

  5. Als uw app een andere taal dan het Engels moet begrijpen, moet u cultuur wijzigen in de juiste taal.

  6. Hier kunt u ook een beschrijving van uw nieuwe LUIS-app toevoegen.

    LUIS - Een nieuwe app maken

  7. Wanneer u op Done drukt, voert u de pagina Build van uw nieuwe LUIS-toepassing in.

  8. Er zijn hier enkele belangrijke concepten die u moet begrijpen:

    • Intent 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 dat informatie beschrijft die relevant is voor de INTENT.
    • Utterances zijn voorbeelden van query's die door de ontwikkelaar worden geleverd en die LUIS gebruikt om zichzelf te trainen.

Als deze concepten niet perfect duidelijk zijn, maakt u zich geen zorgen, aangezien deze cursus deze verderop in dit hoofdstuk zal verduidelijken.

U begint met het maken van de entiteiten die nodig zijn om deze cursus te bouwen.

  1. Klik aan de linkerkant van de pagina op Entiteiten en klik vervolgens op Nieuwe entiteit maken.

    Nieuwe entiteit maken

  2. Roep de nieuwe entiteitskleur aan, stel het type in op Eenvoudig en druk op Done.

    Eenvoudige entiteit maken - kleur

  3. Herhaal dit proces om drie (3) meer Simple Entities met de naam te maken:

    • Converteren
    • Krimpen
    • Doel

Het resultaat moet er uitzien zoals in de onderstaande afbeelding:

Resultaat van het maken van een entiteit

Op dit moment kunt u beginnen met het maken van intenties.

Waarschuwing

Verwijder de intentie Geen niet.

  1. Klik aan de linkerkant van de pagina op Intents en klik vervolgens op Create new intent.

    Nieuwe intenties maken

  2. Roep de nieuwe Intent ChangeObjectColor aan.

    Belangrijk

    Deze intentienaam wordt later in deze cursus in de code gebruikt, dus voor de beste resultaten gebruikt u deze naam precies zoals opgegeven.

Zodra u de naam hebt bevestigd, wordt u omgeleid naar de pagina Intenties.

LUIS - 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 woorden.

  1. Voeg de volgende utterance in het bovenste tekstvak in (momenteel met de tekst Typ ongeveer 5 voorbeelden... ), en druk op Enter:
The color of the cylinder must be red

U ziet dat de nieuwe utterance wordt weergegeven in een lijst eronder.

Voeg na hetzelfde proces de volgende zes (6) utterances 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 utterance 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 kleurEntiteit en alle mogelijke verwijzing naar een doel als een doelentiteit.

  1. Als u dit wilt doen, klikt u op het woord cilinder in de eerste utterance en selecteert u doel.

    Uitingsdoelen identificeren

  2. Klik nu op het woord rood in de eerste utterance en selecteer kleur.

    Utterance-entiteiten identificeren

  3. Label ook de volgende regel, waarbij kubus een doel moet zijn en zwart een kleur moet hebben. U ziet ook het gebruik van de woorden 'this', 'it' en 'this object', die we bieden, zodat er ook niet-specifieke doeltypen beschikbaar zijn.

  4. Herhaal het bovenstaande proces totdat de entiteiten zijn gelabeld voor alle utterances. Zie de onderstaande afbeelding als u hulp nodig hebt.

    Tip

    Wanneer u woorden selecteert om ze als entiteiten te labelen:

    • Voor enkele woorden klikt u erop.
    • 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!

  5. De resultaten moeten zijn zoals weergegeven in de onderstaande afbeeldingen, met de weergave Entiteiten/tokens:

    Tokens & Entiteiten-weergaven

  6. Klik nu op de knop Trainen rechtsboven op de pagina en wacht tot de kleine ronde indicator groen is. Dit geeft aan dat LUIS is getraind om deze intentie te herkennen.

    LUIS trainen

  7. Als oefening voor u maakt u een nieuwe intentie met de naam ChangeObjectSize, met behulp van het doelentiteitendoel , upsize en downsize.

  8. Voeg na hetzelfde proces als de vorige intentie de volgende acht (8) utterances in voor Wijziging van grootte:

    increase the dimensions of that
    
    reduce the size of this
    
    i want the sphere smaller
    
    make the cylinder bigger
    
    size down the sphere
    
    size up the cube
    
    decrease the size of that object
    
    increase the size of this object
    
  9. Het resultaat moet er als het resultaat in de onderstaande afbeelding uit zien:

    De ChangeObjectSize-tokens/-entiteiten instellen

  10. Zodra beide Intents, ChangeObjectColor en ChangeObjectSize zijn gemaakt en getraind, klikt u op de knop PUBLICEREN boven aan de pagina.

    LUIS-service publiceren

  11. Op de pagina Publiceren rondt u uw LUIS-app af en publiceert u deze, zodat deze toegankelijk is voor uw code.

    1. Stel de vervolgkeuzeset Publiceren naar in op Productie.

    2. Stel de Tijdzone in op uw tijdzone.

    3. Vink het selectievakje Alle voorspelde intentiescores opnemen aan.

    4. Klik op Publiceren naar productiesleuf.

      Een Instellingen

  12. In de sectie Resources en sleutels:

    1. Selecteer de regio die u voor het service-exemplaar in de Azure-portal hebt ingesteld.
    2. Hieronder ziet u een Starter_Key element, negeer dit.
    3. 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 vervolgkeuzemenu's voor Tenantnaam, Abonnementsnaam en De sleutel die u wilt gebruiken (heeft dezelfde naam als u eerder hebt opgegeven in de Azure-portal.

    Belangrijk

    Maak onder Eindpunt een kopie van het eindpunt dat overeenkomt met de sleutel die u hebt ingevoegd. U gebruikt deze binnenkort in uw code.

Hoofdstuk 3: Het Unity-project instellen

Hier volgt een typische set-up voor het ontwikkelen met de mixed reality, en als zodanig is een goede sjabloon voor andere projecten.

  1. Open Unity en klik op New.

    Start een nieuw Unity-project.

  2. U moet nu een Unity-naam Project en deze MR_LUIS. Zorg ervoor dat het projecttype is ingesteld op 3D. Stel de Locatie in op een locatie die geschikt is voor u (onthoud dat dichter bij de hoofddirecties beter is). Klik vervolgens op Project maken.

    Geef details op voor het nieuwe Unity-project.

  3. Als Unity is geopend, is het de moeite waard om te controleren of de standaard scripteditor is ingesteld op Visual Studio. Ga naar > bewerken en navigeer vervolgens vanuit het nieuwe venster naar Externe hulpprogramma's. Wijzig External Script Editor in Visual Studio 2017. Sluit het venster Voorkeuren.

    De voorkeur voor scripteditor bijwerken.

  4. Ga vervolgens naar File > Build Instellingen en schakel het platform over naar Universal Windows Platform door op de knop Switch Platform te klikken.

    Bouw Instellingen venster, schakel platform over naar UWP.

  5. Ga naar > Build Instellingen en zorg ervoor dat:

    1. Doelapparaat is ingesteld op Elk apparaat

      Voor de Microsoft HoloLens stelt u Doelapparaat in op HoloLens.

    2. Buildtype is ingesteld op D3D

    3. SDK is ingesteld op Meest recent geïnstalleerd

    4. Visual Studio versie is ingesteld op Meest recent geïnstalleerd

    5. Bouwen en uitvoeren is ingesteld op Lokale machine

    6. Sla de scène op en voeg deze toe aan de build.

      1. Selecteer hiervoor Open scenes toevoegen. Er wordt een venster opslaan weergegeven.

        Klik op de knop Open scenes toevoegen

      2. Maak een nieuwe map voor deze scène en een toekomstige scène en selecteer vervolgens de knop Nieuwe map om een nieuwe map te maken met de naam Scènes.

        Nieuwe map met scripts maken

      3. Open de zojuist gemaakte map Scènes en typ in het tekstveld Bestandsnaam: MR_LuisScene en druk op Opslaan.

        Geef een naam op voor de nieuwe scène.

    7. De overige instellingen, in Build Instellingen, moeten voor nu standaard worden gebruikt.

  6. Klik in het venster Build Instellingen op de knop Player Instellingen. Hiermee opent u het bijbehorende deelvenster in de ruimte waar de Inspector zich bevindt.

    Open de instellingen van de speler.

  7. In dit deelvenster moeten enkele instellingen worden geverifieerd:

    1. Op het tabblad Instellingen volgende opties:

      1. Scripting Runtime Version moet stabiel zijn (.NET 3.5 Equivalent).

      2. Scriptback-end moet .NET zijn

      3. Api-compatibiliteitsniveau moet .NET 4.6 zijn

        Werk andere instellingen bij.

    2. Controleer op het tabblad Instellingen onder Mogelijkheden het volgende:

      1. InternetClient

      2. Microfoon

        Publicatie-instellingen bijwerken.

    3. Tik verderop in het deelvenster, in XR Instellingen (onder Publish Instellingen), op Virtual Reality Supported en zorg ervoor dat de Windows Mixed Reality SDK is toegevoegd.

      Werk de X R-Instellingen.

  8. Terug in Build Instellingen Unity C#-projecten niet langer grijs; vink het selectievakje er naast aan.

  9. Sluit het venster Build Settings.

  10. Sla uw scène en Project op (> SCÈNE/BESTAND opslaan om > PROJECT OP TE SLAAN).

Hoofdstuk 4: De scène maken

Belangrijk

Als u het Unity Set up-onderdeel van deze cursus wilt overslaan en meteen door wilt gaan naar code, kunt u dit .unitypackagedownloaden, het importeren in uw project als een aangepast pakket envervolgens doorgaan vanaf hoofdstuk 5.

  1. Klik met de rechtermuisknop in een leeg gebied van het deelvenster Hiërarchie, voeg onder 3D-object een vlak toe.

    Maak een vlak.

  2. Wanneer u opnieuw met de rechtermuisknop in de hiërarchie klikt om meer objecten te maken en u nog steeds het laatste object hebt geselecteerd, wordt het geselecteerde object het bovenliggende object van het nieuwe object. Voorkom dat u in een lege ruimte in de hiërarchie op deze knop klikt en klik vervolgens met de rechtermuisknop.

  3. Herhaal de bovenstaande procedure om de volgende objecten toe te voegen:

    1. Sphere
    2. Cilinder
    3. Kubus
    4. 3D-tekst
  4. De resulterende scèneHiërarchie moet er als het goed zijn in de onderstaande afbeelding:

    Installatie scènehiërarchie.

  5. Klik met de linker muisklik op de hoofdcamera om deze te selecteren. In het deelvenster Inspector ziet u het cameraobject met alle onderdelen.

  6. Klik op de knop Onderdeel toevoegen onderaan het deelvenster Inspector.

    Audiobron toevoegen

  7. Zoek naar het onderdeel met de naam Audiobron, zoals hierboven wordt weergegeven.

  8. Zorg er ook voor dat het onderdeel Transformeren van de hoofdcamera is ingesteld op (0,0,0). U kunt dit doen door op het tandwielpictogram naast het onderdeel Transformeren van de camera te drukken en Opnieuw instellen te selecteren. Het onderdeel Transformeren moet er dan als volgende uitzien:

    1. De positie is ingesteld op 0, 0, 0.
    2. Rotatie is ingesteld op 0, 0, 0.

    Notitie

    Voor de Microsoft HoloLens moet u ook het volgende wijzigen, dat deel uitmaakt van het onderdeel Camera, dat zich op de hoofdcamera van de camera voordeden:

    • Clear Flags: Effen kleur.
    • Achtergrond 'Black, Alpha 0' – Hex color: #00000000.
  9. Klik met de linker muisklik op het vlak om deze te selecteren. Stel in het deelvenster Inspector het onderdeel Transformeren in met de volgende waarden:

    X-as Y-as Z-as
    0 -1 0
  10. Klik met de linker muisklik op de Bol om deze te selecteren. Stel in het deelvenster Inspector het onderdeel Transformeren in met de volgende waarden:

    X-as Y-as Z-as
    2 1 2
  11. Klik met de linker muis op de cilinder om deze te selecteren. Stel in het deelvenster Inspector het onderdeel Transformeren in met de volgende waarden:

    X-as Y-as Z-as
    -2 1 2
  12. Klik met de linker muisklik op de kubus om deze te selecteren. Stel in het deelvenster Inspector het onderdeel Transformeren in met de volgende waarden:

    Transformeren - Positie | Transformeren - rotatie
    X Y Z | X Y Z
    0 1 4 | 45 45 0
  13. Klik met de linkerkant op het object Nieuwe tekst om dit te selecteren. Stel in het deelvenster Inspector het onderdeel Transformeren in met de volgende waarden:

    Transformeren - Positie | Transformeren - schalen
    X Y Z | X Y Z
    -2 6 9 | 0,1 0,1 0,1
  14. Wijzig tekengrootte in het text mesh-onderdeel in 50.

  15. Wijzig de naam van het Text Mesh-object in Dictation Text.

    Een 3D Text-object maken

  16. De structuur van het hiërarchiepaneel moet er nu als volgende uitzien:

    tekst-mesh in scèneweergave

  17. De uiteindelijke scène moet er uitzien zoals in de onderstaande afbeelding:

    De scèneweergave.

Hoofdstuk 5: de MicrophoneManager-klasse maken

Het eerste script dat u gaat maken, is de klasse MicrophoneManager. Hierna maakt u de LuisManager, de klasse Gedragingen en ten laatste de klasse Staren (u kunt deze nu allemaal maken, maar dit wordt behandeld wanneer u elk hoofdstuk bereikt).

De microphoneManager-klasse is verantwoordelijk voor:

  • Het opnameapparaat detecteren dat is gekoppeld aan de headset of machine (wat de standaardinstelling is).
  • Leg de audio (stem) vast en gebruik dicteren om deze op te slaan als een tekenreeks.
  • Zodra de stem is onderbroken, dient u de dictatie in bij de luismanager-klasse.

Deze klasse maken:

  1. Klik met de rechtermuisknop in Project deelvenster , maak > map. Roep de map Scripts aan.

    Maak de map Scripts.

  2. Nu de map Scripts is gemaakt, dubbelklikt u erop om deze te openen. Klik vervolgens in die map met de rechtermuisknop op Maken > C#-script. Noem het script MicrophoneManager.

  3. Dubbelklik op MicrophoneManager om het te openen met Visual Studio.

  4. Voeg de volgende naamruimten toe aan de bovenkant van het bestand:

        using UnityEngine;
        using UnityEngine.Windows.Speech;
    
  5. 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 result
    
  6. Code voor de methoden 10() en Start() moet nu worden toegevoegd. Deze worden aangeroepen wanneer de klasse het volgende initialiseert:

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
        void Start()
        {
            if (Microphone.devices.Length > 0)
            {
                StartCapturingAudio();
                Debug.Log("Mic Detected");
            }
        }
    
  7. U hebt nu de methode nodig die de app gebruikt om de spraakopname te starten en te stoppen, en deze 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...");
        }
    
  8. Voeg een Dictation Handler toe die wordt aangeroepen wanneer de stem wordt onderbroken. Met deze methode wordt de dicteertekst aan de luismanager-klasse doorgeven.

        /// <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 update()-methode omdat deze klasse deze niet gebruikt.

  9. Zorg ervoor dat u uw wijzigingen in de Visual Studio voordat u terugkeert naar Unity.

    Notitie

    Op dit punt ziet u een fout die wordt weergegeven in het deelvenster van de Unity Editor-console. 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 dat u de LuisManager-klasse maakt, waarmee de aanroep naar de Azure LUIS-service wordt uitgevoerd.

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.

Deze klasse deserialiseert het JSON-antwoord en roept de juiste methoden van de klasse Gedrag aan om een actie te activeren.

Deze klasse maken:

  1. Dubbelklik op de map Scripts om deze te openen.

  2. Klik met de rechtermuisknop in de map Scripts en klik op > C#-script. Noem het script LuisManager.

  3. Dubbelklik op het script om het te openen met Visual Studio.

  4. Voeg de volgende naamruimten toe aan de bovenkant van het bestand:

        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. 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;
        }
    
  6. Voeg vervolgens de volgende variabelen toe in de luisManager-klasse:

        public static LuisManager instance;
    
        //Substitute the value of luis Endpoint with your own End Point
        string luisEndpoint = "https://westus.api.cognitive... add your endpoint from the Luis Portal";
    
  7. Zorg ervoor dat u uw LUIS-eindpunt nu in het eindpunt (dat u hebt van uw LUIS-portal) hebt.

  8. Er moet nu code voor de methode Awake() worden toegevoegd. Deze methode wordt aangeroepen wanneer de klasse het volgende initialiseert:

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  9. U hebt nu de methoden nodig die door deze toepassing worden gebruikt om de dictering die is ontvangen van de klasse MicrophoneManager naar LUIS te verzenden en vervolgens het antwoord te ontvangen en te deserialiseren.

  10. Zodra de waarde van de intentie en de bijbehorende entiteiten zijn vastgesteld, worden ze doorgegeven aan het exemplaar van de klasse Gedrag 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;
            }
        }
    
  11. Maak een nieuwe methode met de naam AnalyseResponseElements() die de resulterende AnalyseQuery leest en de entiteiten bepaalt. Zodra deze entiteiten zijn vastgesteld, worden ze doorgegeven aan het exemplaar van de klasse Gedrag om te gebruiken in de acties.

        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.

  12. Zorg ervoor dat u uw wijzigingen in de Visual Studio voordat u terugkeert naar Unity.

Notitie

Op dit punt ziet u verschillende fouten die worden weergegeven in het deelvenster van de Unity Editor-console. Dit komt doordat de code verwijst naar de klasse Gedragingen die u in het volgende hoofdstuk maakt.

Hoofdstuk 7: de klasse Gedrag maken

De klasse Gedragingen activeert de acties met behulp van de entiteiten die worden geleverd door de luisManager-klasse.

Deze klasse maken:

  1. Dubbelklik op de map Scripts om deze te openen.

  2. Klik met de rechtermuisknop in de map Scripts en klik op > C#-script. Noem het script Gedrag.

  3. Dubbelklik op het script om het te openen met Visual Studio.

  4. Voeg vervolgens de volgende variabelen toe in de klasse Gedrag:

        public static Behaviours instance;
    
        // the following variables are references to possible targets
        public GameObject sphere;
        public GameObject cylinder;
        public GameObject cube;
        internal GameObject gazedTarget;
    
  5. Voeg de methodeCode Bijen() toe. Deze methode wordt aangeroepen wanneer de klasse het volgende initialiseert:

        void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  6. 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 te activeren.

        /// <summary>
        /// Changes the color of the target GameObject by providing the name of the object
        /// and the name of the color
        /// </summary>
        public void ChangeTargetColor(string targetName, string colorName)
        {
            GameObject foundTarget = FindTarget(targetName);
            if (foundTarget != null)
            {
                Debug.Log("Changing color " + colorName + " to target: " + foundTarget.name);
    
                switch (colorName)
                {
                    case "blue":
                        foundTarget.GetComponent<Renderer>().material.color = Color.blue;
                        break;
    
                    case "red":
                        foundTarget.GetComponent<Renderer>().material.color = Color.red;
                        break;
    
                    case "yellow":
                        foundTarget.GetComponent<Renderer>().material.color = Color.yellow;
                        break;
    
                    case "green":
                        foundTarget.GetComponent<Renderer>().material.color = Color.green;
                        break;
    
                    case "white":
                        foundTarget.GetComponent<Renderer>().material.color = Color.white;
                        break;
    
                    case "black":
                        foundTarget.GetComponent<Renderer>().material.color = Color.black;
                        break;
                }          
            }
        }
    
        /// <summary>
        /// Reduces the size of the target GameObject by providing its name
        /// </summary>
        public void DownSizeTarget(string targetName)
        {
            GameObject foundTarget = FindTarget(targetName);
            foundTarget.transform.localScale -= new Vector3(0.5F, 0.5F, 0.5F);
        }
    
        /// <summary>
        /// Increases the size of the target GameObject by providing its name
        /// </summary>
        public void UpSizeTarget(string targetName)
        {
            GameObject foundTarget = FindTarget(targetName);
            foundTarget.transform.localScale += new Vector3(0.5F, 0.5F, 0.5F);
        }
    
  7. Voeg de methode FindTarget() toe om te bepalen welke van de GameObjects het doel van de huidige intentie is. Met deze methode wordt het doel standaard ingesteld op het GameObject dat 'starend' is 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.

  8. Zorg ervoor dat u uw wijzigingen in de Visual Studio voordat u terugkeert naar Unity.

Hoofdstuk 8: de Staring-klasse maken

De laatste klasse die u nodig hebt om deze app te voltooien, is de Staring-klasse. Met deze klasse wordt de verwijzing bijgewerkt naar het GameObject dat zich momenteel in de visuele focus van de gebruiker richt.

Deze klasse maken:

  1. Dubbelklik op de map Scripts om deze te openen.

  2. Klik met de rechtermuisknop in de map Scripts en klik op > C#-script. Noem het script Staren.

  3. Dubbelklik op het script om het te openen met Visual Studio.

  4. 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;
                }
            }
        }
    
  5. Zorg ervoor dat u uw wijzigingen in de Visual Studio voordat u terugkeert naar Unity.

Hoofdstuk 9: de scène-installatie voltooien

  1. 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 Main Camera in het hiërarchiepaneel.

  2. Selecteer de hoofdcamera en bekijk het deelvenster Inspector. U zou elk script moeten kunnen zien dat u hebt gekoppeld. U zult merken dat er parameters zijn voor elk script dat nog moet worden ingesteld.

    De cameraverwijzingsdoelen instellen.

  3. Volg deze instructies om deze parameters correct in te stellen:

    1. MicrophoneManager:

      • Sleep vanuit het deelvenster Hierarchy het object Dictation Text naar het parameterwaardevak Dictation Text.
    2. Gedragingen, van het deelvenster Hiërarchie:

      • Sleep het Sphere-object naar het vak Sphere-referentiedoel.
      • Sleep de cilinder naar het referentiedoelvak Cilinder.
      • Sleep de kubus naar het vak Kubusverwijzingsdoel.
    3. Staren:

      • Stel de maximale staringafstand in op 300 (als dit nog niet is).
  4. Het resultaat moet er uitzien zoals in de onderstaande afbeelding:

    De cameraverwijzingsdoelen worden nu weergegeven.

Hoofdstuk 10: Testen in de Unity-editor

Test of de scène-installatie correct is geïmplementeerd.

Zorg ervoor dat:

  • Alle scripts zijn gekoppeld aan het object Main Camera.
  • Alle velden in het deelvenster Hoofdcamera inspector zijn correct toegewezen.
  1. Druk op de knop Afspelen in de Unity Editor. De app moet worden uitgevoerd binnen de gekoppelde immersive headset.

  2. Probeer enkele utterances, zoals:

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

    Notitie

    Als u in de Unity-console een fout ziet over het wijzigen van het standaard audioapparaat, 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 deze fout wordt weergegeven, stopt u de scène en start u de scène opnieuw. Het werkt dan zoals verwacht.

Hoofdstuk 11: De UWP-oplossing bouwen en sideloaden

Zodra u ervoor hebt gezorgd dat de toepassing werkt in de Unity Editor, bent u klaar om te bouwen en te implementeren.

Om te bouwen:

  1. Sla de huidige scène op door te klikken op Bestand > Opslaan.

  2. Ga naar Bestand > Build Instellingen.

  3. Tik op het vak Unity C# Projects (handig voor het bekijken en debuggen van uw code zodra het UWP-project is gemaakt).

  4. Klik op Open scènes toevoegen en klik vervolgens op Build.

    Venster Instellingen bouwen

  5. U wordt gevraagd om de map te selecteren waarin u de oplossing wilt bouwen.

  6. Maak een BUILDS-map en maak in die map een andere map met de juiste naam van uw keuze.

  7. Klik op Map selecteren om de build op die locatie te starten.

    Map Builds maken  Map builds selecteren

  8. Zodra unity klaar is met bouwen (dit kan enige tijd duren), wordt er een Verkenner-venster geopend op de locatie van uw build.

Implementeren op lokale computer:

  1. Open Visual Studio het oplossingsbestand dat is gemaakt in het vorige hoofdstuk.

  2. Selecteer in solution platform x86, Local Machine.

  3. Selecteer in oplossingsconfiguratie de optie Fouten opsporen.

    Voor de Microsoft HoloLens is het wellicht eenvoudiger om deze in te stellen op Externe computer, zodat u niet aan uw computer bent vastgesteed. U moet echter ook het volgende doen:

    • Het IP-adres van uw HoloLens, dat u kunt vinden in Instellingen > Network & Internet > Wi-Fi > Advanced Options; het IPv4-adres is het adres dat u moet gebruiken.
    • Zorg ervoor dat de ontwikkelaarsmodus is aan; te vinden in Instellingen > Update & Security > For developers.

    App implementeren

  4. Ga naar het menu Bouwen en klik op Oplossing implementeren om de toepassing naar uw computer te sideloaden.

  5. Uw app wordt nu weergegeven in de lijst met geïnstalleerde apps, klaar om te worden gestart.

  6. Zodra de app is gestart, wordt u gevraagd om toegang tot de microfoon te verlenen. 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 zeer belangrijk en moet mogelijk meerdere keren worden iterated, omdat dit helpt de nauwkeurigheid van uw LUIS-service te verbeteren: zorg ervoor dat u dit voltooit.

Als u het kennisniveau van LUIS wilt verbeteren, moet u nieuwe utterances vastleggen en deze gebruiken om uw LUIS-app opnieuw te trainen.

Misschien hebt u LUIS bijvoorbeeld getraind om 'Toename' en 'Upsize' te begrijpen, maar wilt u niet dat uw app ook woorden als 'Vergroten' begrijpt?

Zodra u uw toepassing een paar keer hebt gebruikt, wordt alles wat u hebt gezegd verzameld door LUIS en beschikbaar in de LUIS-PORTAL.

  1. Ga naar uw portaltoepassing via deze KOPPELINGen meld u aan.

  2. Wanneer u bent aangemeld met uw MS-referenties, klikt u op de naam van uw app.

  3. Klik op de knop Eindpunt-utterances controleren aan de linkerkant van de pagina.

    Utterances beoordelen

  4. U ziet een lijst met de utterances die door uw toepassing naar LUIS zijn mixed reality verzonden.

    Lijst met utterances

U ziet enkele gemarkeerde entiteiten.

Door de muisaanwijzer over 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 geconstateerd dat het woord 'spear' is gemarkeerd als een doel, dus moet de fout worden gecorrigeerd. Dit wordt gedaan door met de muis over het woord te bewegen en op Label verwijderen te klikken.

Utterances Remove  Label Image controleren

  1. Als u utterances vindt die volledig verkeerd zijn, kunt u ze verwijderen met behulp van de knop Verwijderen aan de rechterkant van het scherm.

    Verkeerde utterances verwijderen

  2. Als u denkt dat LUIS de uiting correct heeft geïnterpreteerd, kunt u het begrip ervan valideren met behulp van de knop Toevoegen aan uitgelijnde intentie.

    Toevoegen aan uitgelijnde intentie

  3. Nadat u alle weergegeven utterances hebt gesorteerd, probeert u de pagina opnieuw te laden om te zien of er meer beschikbaar zijn.

  4. Het is heel belangrijk om dit proces zo vaak mogelijk te herhalen om het begrip van uw toepassing te verbeteren.

Veel plezier!

Uw voltooide geïntegreerde LUIS-toepassing

Gefeliciteerd, u hebt een mixed reality-app gemaakt die gebruik maakt van de Azure Language Understanding Intelligence Service, om te begrijpen wat een gebruiker zegt en actie te ondernemen op die informatie.

Labresultaat

Bonusoefeningen

Oefening 1

Tijdens het gebruik van deze toepassing merkt u misschien dat als u naar het Floor-object start en vraagt om de kleur ervan te wijzigen, dit wel gebeurt. Kunt u erachter komen hoe u kunt voorkomen dat uw toepassing de kleur van de vloer verandert?

Oefening 2

Probeer de luis- en app-mogelijkheden uit te breiden en extra functionaliteit toe te voegen voor objecten in scène; Maak bijvoorbeeld nieuwe objecten op het trefferpunt Staren, afhankelijk van wat de gebruiker zegt, en kan deze objecten vervolgens naast huidige scèneobjecten gebruiken met de bestaande opdrachten.