HoloLens (första generationen) och Azure 303: Förståelse för naturligt språk (LUIS)


Anteckning

Självstudierna Mixed Reality Academy har utformats med HoloLens (1:a gen) och Mixed Reality Immersive Headsets i åtanke. Därför anser vi att det är viktigt att lämna de här självstudierna på plats för utvecklare som fortfarande letar efter vägledning i utvecklingen för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygen eller interaktionerna som används för HoloLens 2. De kommer att finnas kvar för att fortsätta arbeta med de enheter som stöds. Det kommer att finnas en ny serie självstudier som kommer att publiceras i framtiden som visar hur du utvecklar för HoloLens 2. Det här meddelandet uppdateras med en länk till dessa självstudier när de publiceras.


I den här kursen får du lära dig hur du integrerar Language Understanding i ett mixed reality-program med Azure Cognitive Services, med Language Understanding-API:et.

Labbresultat

Language Understanding (LUIS) är en Microsoft Azure-tjänst som ger program möjlighet att göra betydelse av användarindata, till exempel genom att extrahera vad en person kan vilja, med sina egna ord. Detta uppnås genom maskininlärning, som förstår och lär sig indatainformationen och sedan kan svara med detaljerad, relevant information. Mer information finns på sidan för Azure Language Understanding (LUIS).

När du har slutfört den här kursen har du ett avancerad headset-program med mixad verklighet som kan göra följande:

  1. Samla in användarens indatatal med hjälp av mikrofonen som är ansluten till det integrerande headset.
  2. Skicka den avbildade dikteringsfrasen till Azure Language Understanding Intelligent Service (LUIS).
  3. Låt LUIS extrahera betydelse från den skickande informationen, som kommer att analyseras, och försök att fastställa avsikten med användarens begäran görs.

Utvecklingen omfattar att skapa en app där användaren kan använda röst och/eller blick för att ändra storlek och färg på objekten i scenen. Användning av rörelsekontroller omfattas inte.

I ditt program är det upp till dig hur du ska integrera resultaten med din design. Den här kursen är utformad för att lära dig hur du integrerar en Azure-tjänst med ditt Unity-Project. Det är ditt jobb att använda den kunskap du får från den här kursen för att förbättra programmet för mixad verklighet.

Var beredd på att träna LUIS flera gånger, vilket tas upp i kapitel 12. Du får bättre resultat ju fler gånger SOM LUIS har tränats.

Stöd för enheter

Kurs HoloLens Integrerande headset
MR och Azure 303: Förståelse av naturligt språk (LUIS) ✔️ ✔️

Anteckning

Även om den här kursen främst fokuserar Windows Mixed Reality integrerande (VR)-headset kan du även använda det du lär dig i den här kursen för att Microsoft HoloLens. När du följer med i kursen visas anteckningar om eventuella ändringar som du kan behöva använda för att stödja HoloLens. När du HoloLens kan du märka ett visst eko under röstinfångst.

Förutsättningar

Anteckning

Den här självstudien är utformad för utvecklare som har grundläggande erfarenhet av Unity och C#. Tänk också på att förutsättningarna och de skrivna anvisningarna i det här dokumentet representerar det som har testats och verifierats i skrivande stund (maj 2018). Du kan använda den senaste programvaran enligt listan i artikeln Installera verktyg, men det bör inte antas att informationen i den här kursen matchar det du hittar i nyare programvara än vad som anges nedan.

Vi rekommenderar följande maskin- och programvara för den här kursen:

Innan du börjar

  1. För att undvika problem med att skapa det här projektet rekommenderar vi starkt att du skapar projektet som nämns i den här självstudien i en rotmapp eller nära rotmappen (långa mappsökvägar kan orsaka problem vid byggtiden).

  2. Om du vill tillåta att din dator aktiverar diktering går du till Windows Inställningar > Privacy > Speech, Inking & Typing (Intkning &) och trycker på knappen Turn On speech services (Aktivera taltjänster) och skriver förslag .

  3. Koden i den här självstudien gör att du kan spela in från den standardenhet för mikrofon som angetts på datorn. Kontrollera att Standardmi mikrofonenheten är inställd som den som du vill använda för att spela in din röst.

  4. Om ditt headset har en inbyggd mikrofon kontrollerar du att alternativet "När jag har på mig headset, byt till headset mic" är aktiverat i Portalen för Mixad verklighet inställningar.

    Konfigurera integrerande headset

Kapitel 1 – Konfigurera Azure-portalen

Om du Language Understanding tjänsten i Azure måste du konfigurera en instans av tjänsten som ska göras tillgänglig för ditt program.

  1. Logga in på Azure Portal.

    Anteckning

    Om du inte redan har ett Azure-konto måste du skapa ett. Om du följer den här självstudien i ett klassrum eller ett labb kan du be din lärare eller någon av proktorerna om hjälp med att konfigurera ditt nya konto.

  2. När du är inloggad klickar du på Nytt i det övre vänstra hörnet och söker efter Language Understanding och klickar på Retur.

    Skapa LUIS-resurs

    Anteckning

    Ordet Ny kan ha ersatts med Skapa en resurs i nyare portaler.

  3. Den nya sidan till höger ger en beskrivning av Language Understanding tjänsten. Längst ned till vänster på den här sidan väljer du knappen Skapa för att skapa en instans av den här tjänsten.

    Skapande av LUIS-tjänst – juridiskt meddelande

  4. När du har klickat på Skapa:

    1. Infoga önskat namn för den här tjänstinstansen.

    2. Välj en prenumeration.

    3. Välj den prisnivå som passar dig. Om det är första gången du skapar en LUIS-tjänst ska du ha en kostnadsfri nivå (med namnet F0). Den kostnadsfria allokeringen bör vara mer än tillräcklig för den här kursen.

    4. Välj en resursgrupp eller skapa en ny. En resursgrupp är ett sätt att övervaka, kontrollera åtkomst, etablera och hantera fakturering för en samling Azure-tillgångar. Vi rekommenderar att du behåller alla Azure-tjänster som är associerade med ett enda projekt (t.ex. dessa kurser) under en gemensam resursgrupp).

      Om du vill läsa mer om Azure-resursgrupper kan du läsa resursgruppsartikeln.

    5. Fastställ platsen för resursgruppen (om du skapar en ny resursgrupp). Platsen skulle helst vara i den region där programmet skulle köras. Vissa Azure-tillgångar är bara tillgängliga i vissa regioner.

    6. Du måste också bekräfta att du har förstått de allmänna villkor som gäller för den här tjänsten.

    7. Välj Skapa.

      Skapa LUIS-tjänst – användarindata

  5. När du har klickat Skapa måste du vänta tills tjänsten har skapats. Det kan ta en minut.

  6. Ett meddelande visas i portalen när tjänstinstansen har skapats.

    Ny Azure-aviseringsavbildning

  7. Klicka på meddelandet för att utforska den nya tjänstinstansen.

    Meddelande om att resursen har skapats

  8. Klicka på knappen Gå till resurs i meddelandet för att utforska din nya tjänstinstans. Du kommer till din nya LUIS-tjänstinstans.

    Åtkomst till LUIS-nycklar

  9. I den här självstudien måste ditt program göra anrop till tjänsten, vilket görs med hjälp av tjänstens prenumerationsnyckel.

  10. På sidan Snabbstart i DIN LUIS API-tjänst går du till det första steget, Hämtar dina nycklar och klickar på Nycklar (du kan också åstadkomma detta genom att klicka på den blå hyperlänken Nycklar, som finns i tjänstnavigeringsmenyn, som visas med nyckelikonen). Då visas tjänstnycklarna.

  11. Ta en kopia av en av nycklarna som visas, eftersom du behöver den senare i projektet.

  12. På sidan Tjänst klickar du på Language Understanding portal för att omdirigeras till webbsidan som du kommer att använda för att skapa din nya tjänst i LUIS-appen.

Kapitel 2 – Language Understanding portalen

I det här avsnittet får du lära dig hur du gör en LUIS-app på LUIS-portalen.

Viktigt

Tänk på att det bara är första steget i att skapa LUIS-tjänsten att konfigurera entiteter, avsikter och talindata i det här kapitlet: du måste också träna om tjänsten flera gånger för att göra den mer exakt. Omträning av tjänsten finns i det sista kapitlet i den här kursen, så se till att du slutför den.

  1. När du når Language Understanding-portalen kan du behöva logga in, om du inte redan är det, med samma autentiseringsuppgifter som Azure Portal.

    LUIS-inloggningssida

  2. Om det här är första gången du använder LUIS måste du rulla längst ned på välkomstsidan för att hitta och klicka på knappen Skapa LUIS-app.

    Sidan Skapa LUIS-app

  3. När du är inloggad klickar du Mina appar (om du inte är i det avsnittet för närvarande). Du kan sedan klicka på Skapa ny app.

    LUIS – avbildning av mina appar

  4. Ge appen ett namn.

  5. Om din app ska förstå ett annat språk än engelska bör du ändra Kultur till rätt språk.

  6. Här kan du också lägga till en Beskrivning av din nya LUIS-app.

    LUIS – skapa en ny app

  7. När du trycker Klar anger du sidan Skapa för ditt nya LUIS-program.

  8. Det finns några viktiga begrepp att förstå här:

    • Intent, representerar den metod som anropas efter en fråga från användaren. En AVSIKT kan ha en eller flera ENTITETER.
    • Entitet är en komponent i frågan som beskriver information som är relevant för INTENT.
    • Yttranden är exempel på frågor som tillhandahålls av utvecklaren och som LUIS använder för att träna sig själv.

Oroa dig inte om de här begreppen inte är helt tydliga, eftersom den här kursen kommer att tydliggöra dem ytterligare i det här kapitlet.

Du börjar med att skapa de entiteter som behövs för att skapa den här kursen.

  1. Till vänster på sidan klickar du på Entities (Entiteter) och sedan på Create new entity (Skapa ny entitet).

    Skapa en ny entitet

  2. Anropa den nya entitetsfärgen, ange dess typ till Enkel och tryck sedan på Klar.

    Skapa en enkel entitet – färg

  3. Upprepa den här processen för att skapa tre (3) fler enkla entiteter med namnet:

    • Utvidga
    • Minska
    • Mål

Resultatet bör se ut som på bilden nedan:

Resultat av skapande av entitet

Nu kan du börja skapa Avsikter.

Varning

Ta inte bort avsikten None (Ingen).

  1. Till vänster på sidan klickar du på Intents (Avsikter) och sedan på Create new intent (Skapa ny avsikt).

    Skapa nya avsikter

  2. Anropa den nya avsikten ChangeObjectColor.

    Viktigt

    Det här avsiktsnamnet används i koden senare i den här kursen, så använd det här namnet exakt som det anges för bästa resultat.

När du har bekräftat namnet kommer du att dirigeras till sidan Intents (Avsikter).

LUIS – avsiktssida

Du kommer att märka att det finns en textruta där du uppmanas att skriva 5 eller fler olika yttranden .

Anteckning

LUIS konverterar alla yttranden till gemener.

  1. Infoga följande uttryck i den översta textrutan (för närvarande med texten Skriv cirka 5 exempel... ) och tryck på Retur:
The color of the cylinder must be red

Du kommer att märka att det nya yttrandena visas i en lista nedanför.

Efter samma process infogar du följande sex (6) yttranden:

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 varje uttryck som du har skapat måste du identifiera vilka ord som ska användas av LUIS som entiteter. I det här exemplet måste du märka alla färger som en färgentitet och all möjlig referens till ett mål som målentitet.

  1. Det gör du genom att klicka på ordet cylinder i det första tamanten och välja mål.

    Identifiera yttranden mål

  2. Klicka nu på ordet röd i det första tamanten och välj färg.

    Identifiera yttrandentiteter

  3. Märk även nästa rad, där kuben ska vara ett mål och svart ska vara en färg. Observera också användningen av orden "this", "it" och "this object", som vi tillhandahåller, så att även icke-specifika måltyper är tillgängliga.

  4. Upprepa processen ovan tills alla yttranden har entiteterna märkta. Se bilden nedan om du behöver hjälp.

    Tips

    När du väljer ord för att märka dem som entiteter:

    • För enkla ord klickar du bara på dem.
    • Om du vill ha en uppsättning med två eller fler ord klickar du i början och sedan i slutet av uppsättningen.

    Anteckning

    Du kan använda växlingsknappen Tokenvy för att växla mellan entiteter/tokenvy!

  5. Resultatet ska visas i bilderna nedan, som visar vyn Entiteter/Tokens:

    Tokens & Entities Views

  6. Tryck nu på knappen Träna längst upp till höger på sidan och vänta tills den lilla runda indikatorn på den blir grön. Detta anger att LUIS har tränats för att identifiera den här avsikten.

    Träna LUIS

  7. Som en övning för dig skapar du en ny avsikt med namnet ChangeObjectSize, med entitetsmålet, upsize och downsize.

  8. Efter samma process som den tidigare avsikten infogar du följande åtta (8) yttranden för storleksändring:

    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. Resultatet bör se ut som på bilden nedan:

    Konfigurera ChangeObjectSize-token/entiteter

  10. När båda avsikterna, ChangeObjectColor och ChangeObjectSize, har skapats och tränats klickar du på knappen PUBLICERA överst på sidan.

    Publicera LUIS-tjänst

  11. På sidan Publicera slutför du och publicerar LUIS-appen så att den kan nås av din kod.

    1. Ange listrutan Publicera till som produktion.

    2. Ange tidszonen till din tidszon.

    3. Markera kryssrutan Inkludera alla förutsagda avsiktspoäng.

    4. Klicka på Publish to Production Slot (Publicera till produktionsplats).

      Publicera Inställningar

  12. I avsnittet Resurser och nycklar:

    1. Välj den region som du anger för tjänstinstansen i Azure-portalen.
    2. Du ser ett Starter_Key nedan, ignorera det.
    3. Klicka på Lägg till nyckel och infoga den nyckel som du fick i Azure Portal när du skapade tjänstinstansen. Om din Azure och LUIS-portalen är inloggade på samma användare visas listmenyer för Klientnamn, Prenumerationsnamn och Den nyckel som du vill använda (har samma namn som du angav tidigare i Azure-portalen.

    Viktigt

    Under Slutpunkt tar du en kopia av slutpunkten som motsvarar den nyckel som du har infogat. Du kommer snart att använda den i koden.

Kapitel 3 – Konfigurera Unity-projektet

Följande är en typisk uppsättning för utveckling med mixad verklighet och är därför en bra mall för andra projekt.

  1. Öppna Unity och klicka på Ny.

    Starta ett nytt Unity-projekt.

  2. Nu måste du ange ett Unity-Project namn, infoga MR_LUIS. Kontrollera att projekttypen är inställd på 3D. Ställ in Plats på en lämplig plats (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.

    Ange information för det nya Unity-projektet.

  3. När Unity är öppet är det värt att kontrollera att standardskriptredigeraren är inställd på Visual Studio. Gå till Redigera > inställningar och gå sedan till Externa verktyg från det nya fönstret. Ändra Extern skriptredigerare till Visual Studio 2017. Stäng fönstret Inställningar.

    Uppdatera inställningar för skriptredigeraren.

  4. Gå sedan till File > Build Inställningar (Skapa Inställningar) och byt plattform till Universal Windows Platform genom att klicka på knappen Switch Platform (Växla plattform).

    Skapa Inställningar, växla plattform till UWP.

  5. Gå till Fil > Skapa Inställningar och kontrollera att:

    1. Målenheten är inställd på Valfri enhet

      För Microsoft HoloLens anger du Målenhet till HoloLens.

    2. Byggtyp har angetts till D3D

    3. SDK är inställt på Senaste installerade

    4. Visual Studio Version har angetts till Senaste installerade

    5. Skapa och kör är inställt på Lokal dator

    6. Spara scenen och lägg till den i bygget.

      1. Gör detta genom att välja Lägg till öppna scener. Ett save-fönster visas.

        Klicka på knappen Lägg till öppna scener

      2. Skapa en ny mapp för den här och framtida scenen och välj sedan knappen Ny mapp för att skapa en ny mapp, ge den namnet Scenes.

        Skapa en ny skriptmapp

      3. Öppna den nyligen skapade mappen Scenes och skriv sedan i fältet Filnamn: text MR_LuisScene och tryck sedan på Spara.

        Ge den nya scenen ett namn.

    7. De återstående inställningarna, i Build Inställningar, bör vara kvar som standard för tillfället.

  6. I fönstret Skapa Inställningar klickar du på knappen Player Inställningar(Spelare) så öppnas den relaterade panelen i utrymmet där Inspector finns.

    Öppna spelarinställningar.

  7. I den här panelen måste några inställningar verifieras:

    1. På fliken Inställningar inställningar:

      1. Skriptkörningsversion bör vara stabil (.NET 3.5-motsvarighet).

      2. Skript för backend ska vara .NET

      3. API-kompatibilitetsnivån ska vara .NET 4.6

        Uppdatera andra inställningar.

    2. På fliken Inställningar publiceringsfunktion, under Funktioner, markerar du:

      1. InternetClient

      2. Mikrofon

        Uppdatera publiceringsinställningar.

    3. Längre ned i panelen, i XR Inställningar (finns nedan Publicera Inställningar), markerar du Virtual Reality Supported (Virtuell verklighet stöds) och kontrollerar att Windows Mixed Reality SDK har lagts till.

      Uppdatera X R-Inställningar.

  8. Tillbaka i Build Inställningar Är Unity C#-projekt inte längre nedtonade; markera kryssrutan bredvid detta.

  9. Stäng fönstret Build Settings (Bygginställningar).

  10. Spara din scen och Project (FILE > SAVE SCENE/FILE > SAVE PROJECT).

Kapitel 4 – Skapa scenen

Viktigt

Om du vill hoppa över komponenten Unity Set up i den här kursen och fortsätta direkt i koden kan du ladda ned detta .unitypackage,importera det till projektet som ett anpassat paket och sedan fortsätta från kapitel 5.

  1. Högerklicka i ett tomt område på hierarkipanelen och lägg till ett plan under 3D-objekt.

    Skapa ett plan.

  2. Tänk på att när du högerklickar i hierarkin igen för att skapa fler objekt, om du fortfarande har valt det sista objektet, blir det markerade objektet överordnat det nya objektet. Undvik att vänsterklicka i ett tomt utrymme i hierarkin och högerklicka.

  3. Upprepa proceduren ovan för att lägga till följande objekt:

    1. Sphere
    2. Cylinder
    3. Kub
    4. 3D-text
  4. Den resulterande scenhierarkin bör se ut som på bilden nedan:

    Scenhierarkikonfiguration.

  5. Vänsterklicka på huvudkameran för att markera den. På kontrollpanelen ser du objektet Kamera med alla dess komponenter.

  6. Klicka på knappen Lägg till komponent längst ned på kontrollpanelen.

    Lägg till ljudkälla

  7. Sök efter komponenten Audio Source (Ljudkälla) som visas ovan.

  8. Kontrollera också att transformeringskomponenten i huvudkameran är inställd på (0,0,0). Det kan du göra genom att trycka på kugghjulsikonen bredvid kamerans transformeringskomponent och välja Återställ. Transformeringskomponenten bör sedan se ut så här:

    1. Positionen är inställd på 0, 0, 0.
    2. Rotation är inställt på 0, 0, 0.

    Anteckning

    För Microsoft HoloLens måste du också ändra följande, som är en del av komponenten Kamera, som finns på huvudkameran:

    • Rensa flaggor: Solid color (Heldragen färg).
    • Bakgrund "Black, Alpha 0" – Hexadexfärg: #00000000.
  9. Vänsterklicka på planet för att markera det. I kontrollpanelen anger du transformeringskomponenten med följande värden:

    X-axel Y-axel Z-axel
    0 -1 0
  10. Vänsterklicka på Sphere för att markera den. I kontrollpanelen anger du transformeringskomponenten med följande värden:

    X-axel Y-axel Z-axel
    2 1 2
  11. Vänsterklicka på cylindern för att välja den. I kontrollpanelen anger du transformeringskomponenten med följande värden:

    X-axel Y-axel Z-axel
    -2 1 2
  12. Vänsterklicka på kuben för att välja den. I kontrollpanelen anger du transformeringskomponenten med följande värden:

    Transformera – position | Transformera – rotation
    X Y Z | X Y Z
    0 1 4 | 45 45 0
  13. Vänsterklicka på objektet Ny text för att markera det. I kontrollpanelen anger du transformeringskomponenten med följande värden:

    Transformera – position | Transformera – skala
    X Y Z | X Y Z
    -2 6 9 | 0.1 0.1 0.1
  14. Ändra Teckenstorlek i Text Mesh-komponenten till 50.

  15. Ändra namnet Text Mesh-objektet till Dikteringstext.

    Skapa 3D-textobjekt

  16. Hierarkipanelstrukturen bör nu se ut så här:

    textnät i scenvyn

  17. Den sista scenen bör se ut som på bilden nedan:

    Scenvyn.

Kapitel 5 – Skapa MicrophoneManager-klassen

Det första skriptet som du ska skapa är klassen MicrophoneManager. Därefter skapar du klassen LuisManager, klassen Behaviors och slutligen klassen Blick (du kan skapa alla dessa nu, även om du kommer till varje kapitel).

MicrophoneManager-klassen ansvarar för:

  • Identifiera inspelningsenheten som är ansluten till headset eller dator (beroende på vilket som är standardinställningen).
  • Samla in ljudet (rösten) och använd diktering för att lagra det som en sträng.
  • När rösten har pausats skickar du dikteringsmeddelandet till LuisManager-klassen.

Så här skapar du den här klassen:

  1. Högerklicka på panelen Project Skapa> mapp. Anropa mappen Skript.

    Skapa mappen Skript.

  2. När mappen Skript har skapats dubbelklickar du på den för att öppna den. Högerklicka sedan i den mappen på Create > C#Script. Ge skriptet namnet MicrophoneManager.

  3. Dubbelklicka på MicrophoneManager för att öppna den med Visual Studio.

  4. Lägg till följande namnområden överst i filen:

        using UnityEngine;
        using UnityEngine.Windows.Speech;
    
  5. Lägg sedan till följande variabler i klassen 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. Koden för metoderna Awake() och Start() måste nu läggas till. Dessa anropas när klassen initierar:

        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. Nu behöver du den metod som appen använder för att starta och stoppa röstinfångst och skicka den till LuisManager-klassen som du snart ska skapa.

        /// <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. Lägg till en dikteringshanterare som ska anropas när rösten pausar. Den här metoden skickar dikteringstexten till LuisManager-klassen.

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

    Viktigt

    Ta bort metoden Update() eftersom den här klassen inte kommer att använda den.

  9. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

    Anteckning

    Nu visas ett fel i konsolpanelen i Unity-redigeraren. Det beror på att koden refererar till LuisManager-klassen som du skapar i nästa kapitel.

Kapitel 6 – Skapa LUISManager-klassen

Det är dags för dig att skapa luisManager-klassen, som gör anropet till Azure LUIS-tjänsten.

Syftet med den här klassen är att ta emot dikteringstexten från klassen MicrophoneManager och skicka den till Azure Language Understanding-API:et som ska analyseras.

Den här klassen deserialiserar JSON-svaret och anropar lämpliga metoder för beteendeklassen för att utlösa en åtgärd.

Så här skapar du den här klassen:

  1. Dubbelklicka på mappen Skript för att öppna den.

  2. Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet LuisManager.

  3. Dubbelklicka på skriptet för att öppna det med Visual Studio.

  4. Lägg till följande namnområden överst i filen:

        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. Du börjar med att skapa tre klasser i LuisManager-klassen (i samma skriptfil ovanför metoden Start() som representerar det deserialiserade JSON-svaret från Azure.

        [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. Lägg sedan till följande variabler i luisManager-klassen:

        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. Se till att placera LUIS-slutpunkten i nu (som du kommer att ha från LUIS-portalen).

  8. Koden för metoden Awake() måste nu läggas till. Den här metoden anropas när klassen initierar:

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  9. Nu behöver du de metoder som det här programmet använder för att skicka diktering som tagits emot från klassen MicrophoneManager till LUIS och sedan ta emot och deserialisera svaret.

  10. När värdet för avsikten och associerade entiteter har fastställts skickas de till instansen av klassen Behaviors för att utlösa den avsedda åtgärden.

        /// <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. Skapa en ny metod med namnet FörsentResponseElements() som läser den resulterande upphetsningfrågan och fastställer entiteterna. När dessa entiteter har fastställts skickas de till instansen av klassen Behaviors som ska användas i åtgärderna.

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

    Viktigt

    Ta bort metoderna Start() och Update() eftersom den här klassen inte kommer att använda dem.

  12. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

Anteckning

Nu ser du flera fel som visas i konsolpanelen i Unity Editor. Det beror på att koden refererar till klassen Behaviors som du skapar i nästa kapitel.

Kapitel 7 – Skapa klassen Behaviors

Klassen Behaviors utlöser åtgärderna med hjälp av de entiteter som tillhandahålls av LuisManager-klassen.

Så här skapar du den här klassen:

  1. Dubbelklicka på mappen Skript för att öppna den.

  2. Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet Behaviors.

  3. Dubbelklicka på skriptet för att öppna det med Visual Studio.

  4. Lägg sedan till följande variabler i klassen 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;
    
  5. Lägg till metoden Awake(). Den här metoden anropas när klassen initierar:

        void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  6. Följande metoder anropas av LuisManager-klassen (som du skapade tidigare) för att avgöra vilket objekt som är målet för frågan och sedan utlösa lämplig åtgärd.

        /// <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. Lägg till metoden FindTarget() för att avgöra vilket av GameObjects som är målet för den aktuella avsikten. Den här metoden använder som standard målet till att GameObject ska "blickas" om inget explicit mål har definierats i entiteterna.

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

    Viktigt

    Ta bort metoderna Start() och Update() eftersom den här klassen inte kommer att använda dem.

  8. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

Kapitel 8 – Skapa blickklassen

Den sista klassen som du behöver för att slutföra den här appen är klassen Blick. Den här klassen uppdaterar referensen till GameObject som för närvarande är i användarens visuella fokus.

Så här skapar du den här klassen:

  1. Dubbelklicka på mappen Skript för att öppna den.

  2. Högerklicka i mappen Skript och klicka på Skapa > C#-skript. Ge skriptet namnet Blick.

  3. Dubbelklicka på skriptet för att öppna det med Visual Studio.

  4. Infoga följande kod för den här klassen:

        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. Se till att spara ändringarna i Visual Studio innan du återgår till Unity.

Kapitel 9 – Slutföra scenkonfigurationen

  1. Slutför installationen av scenen genom att dra varje skript som du har skapat från mappen Skript till huvudkameraobjektet i hierarkipanelen.

  2. Välj huvudkameran och titta på kontrollpanelen. Du bör kunna se varje skript som du har kopplat, och du kommer att märka att det finns parametrar för varje skript som ännu inte har ställts in.

    Ange kamerareferensmål.

  3. Följ dessa instruktioner om du vill ange parametrarna korrekt:

    1. MicrophoneManager:

      • Dra objektet Dikteringstext från hierarkipanelen till värderutan för parametervärdet Dikteringstext.
    2. Beteenden , från hierarkipanelen:

      • Dra Sphere-objektet till rutan Sphere reference target (Sphere-referensmål).
      • Dra cylindern till rutan cylinderreferensmål.
      • Dra kuben till rutan Kubreferensmål.
    3. Blick:

      • Ställ in Blick maximalt avstånd på 300 (om det inte redan är det).
  4. Resultatet bör se ut som på bilden nedan:

    Visar mål för kamerareferens, nu inställt.

Kapitel 10 – Testa i Unity-redigeraren

Testa att scenkonfigurationen är korrekt implementerad.

Kontrollera att:

  • Alla skript är kopplade till huvudkameraobjektet.
  • Alla fält i huvudpanelen för kamerakontroll är korrekt tilldelade.
  1. Tryck på knappen Spela upp i Unity-redigeraren. Appen bör köras i det anslutna integrerande headsetet.

  2. Prova några yttranden, till exempel:

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

    Anteckning

    Om du ser ett fel i Unity-konsolen om att standardljudenheten ändras kanske scenen inte fungerar som förväntat. Det beror på hur portalen för mixad verklighet hanterar inbyggda mikrofoner för headset som har dem. Om du ser det här felet stoppar du bara scenen och startar den igen så bör allt fungera som förväntat.

Kapitel 11 – Skapa och separat inläsning av UWP-lösningen

När du har sett till att programmet fungerar i Unity-redigeraren är du redo att skapa och distribuera.

Så här skapar du:

  1. Spara den aktuella scenen genom att klicka på Arkiv > Spara.

  2. Gå till File > Build Inställningar.

  3. Markera rutan Unity C# Projects (användbar för att se och felsöka din kod när UWP-projektet har skapats.

  4. Klicka på Lägg till öppna scener och klicka sedan på Skapa.

    Skapa Inställningar fönster

  5. Du uppmanas att välja den mapp där du vill skapa lösningen.

  6. Skapa en BUILDS-mapp och skapa en annan mapp i mappen med ett lämpligt namn.

  7. Klicka på Välj mapp för att påbörja bygget på den platsen.

    Skapa byggmapp välj  mappen Builds (Byggen)

  8. När Unity har byggt klart (det kan ta lite tid) bör det öppna Utforskaren fönster på platsen för bygget.

Så här distribuerar du på den lokala datorn:

  1. I Visual Studio du lösningsfilen som skapades i föregående kapitel.

  2. I Lösningsplattform väljer du x86, Lokal dator.

  3. I Lösningskonfiguration väljer du Felsök.

    För Microsoft HoloLens kan det vara enklare att ställa in detta på Fjärrdator, så att du inte är bundna till datorn. Men du måste också göra följande:

    • Känna till IP-adressen för HoloLens, som finns i Inställningar > Network & Internet > Wi-Fi > Advanced Options; IPv4 är den adress som du bör använda.
    • Se till att Utvecklarläge är På; finns i Inställningar > Update & Security > For developers.

    Distribuera app

  4. Gå till menyn Build (Skapa) och klicka på Deploy Solution (Distribuera lösning) för att separat ladda in programmet till datorn.

  5. Din app bör nu visas i listan över installerade appar, redo att startas!

  6. När appen har startats uppmanas du att auktorisera åtkomst till mikrofonen. Använd rörelsekontroller, eller röstindata, eller tangentbordet för att trycka på KNAPPEN JA.

Kapitel 12 – Förbättra LUIS-tjänsten

Viktigt

Det här kapitlet är otroligt viktigt och kan behöva itereras flera gånger, eftersom det hjälper till att förbättra noggrannheten för din LUIS-tjänst: se till att du slutför detta.

För att förbättra den förståelse som tillhandahålls av LUIS behöver du samla in nya yttranden och använda dem för att träna om DIN LUIS-app.

Du kanske till exempel har tränat LUIS att förstå "Öka" och "Öka", men vill du inte att din app också ska förstå ord som "Förstora"?

När du har använt programmet några gånger samlas allt du har sagt in av LUIS och är tillgängligt i LUIS-PORTALEN.

  1. Gå till ditt portalprogram genom att följa den här LÄNKENoch logga in.

  2. När du har loggat in med dina MS-autentiseringsuppgifter klickar du på appnamnet.

  3. Klicka på knappen Granska slutpunktsyttranden till vänster på sidan.

    Granska yttranden

  4. Du kommer att se en lista över yttranden som har skickats till LUIS av programmet för mixad verklighet.

    Lista över yttranden

Du ser några markerade Entiteter.

Genom att hovra över varje markerat ord kan du granska varje uttryck och avgöra vilken entitet som har identifierats korrekt, vilka entiteter som är fel och vilka entiteter som missas.

I exemplet ovan upptäcktes att ordet "spear" hade markerats som ett mål, så det var nödvändigt att korrigera misstaget, vilket görs genom att hovra över ordet med musen och klicka på Ta bort etikett.

Kontrollera yttranden Ta bort  etikettbild

  1. Om du hittar yttranden som är helt felaktiga kan du ta bort dem med knappen Ta bort till höger på skärmen.

    Ta bort fel yttranden

  2. Eller om du anser att LUIS har tolkat yttranden korrekt kan du verifiera dess förståelse med hjälp av knappen Lägg till i justerad avsikt.

    Lägg till i justerad avsikt

  3. När du har sorterat alla yttranden som visas kan du försöka läsa in sidan igen för att se om det finns fler.

  4. Det är mycket viktigt att upprepa den här processen så många gånger som möjligt för att förbättra programförståelse.

Ha det så kul!

Ditt färdiga LUIS-integrerade program

Grattis! Du har skapat en app för mixad verklighet som använder Azure Language Understanding Intelligence Service för att förstå vad en användare säger och agera på den informationen.

Labbresultat

Bonusövningar

Övning 1

När du använder det här programmet kanske du märker att om du tittar på objektet Floor och ber om att ändra dess färg, kommer det att göra det. Kan du ta reda på hur du kan hindra ditt program från att ändra golvfärgen?

Övning 2

Prova att utöka FUNKTIONERNA FÖR LUIS och app, och lägg till ytterligare funktioner för objekt i scenen. Du kan till exempel skapa nya objekt vid blickens träffpunkt, beroende på vad användaren säger, och sedan kunna använda dessa objekt tillsammans med aktuella scenobjekt med de befintliga kommandona.