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 (första generationen) och Mixed Reality integrerande headset i åtanke. Därför tycker vi att det är viktigt att låta de här självstudierna vara kvar för utvecklare som fortfarande behöver vägledning för att utveckla för dessa enheter. De här självstudierna uppdateras inte med de senaste verktygsuppsättningarna eller interaktionerna som används för HoloLens 2. De kommer att underhållas för att fortsätta arbeta på de enheter som stöds. Det kommer att finnas en ny serie självstudier som kommer att publiceras i framtiden som visar hur man 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 hjälp av Azure Cognitive Services med Language Understanding-API:et.

Lab outcome

Language Understanding (LUIS) är en Microsoft Azure-tjänst som ger program möjlighet att göra mening med användarindata, till exempel genom att extrahera vad en person kanske vill ha, 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).

Efter att ha slutfört den här kursen har du ett integrerande headsetprogram för mixad verklighet som kan göra följande:

  1. Fånga in användarens indatatal med mikrofonen som är ansluten till det integrerande headsetet.
  2. Skicka den avbildade dikteringen Azure Language Understanding Intelligent Service (LUIS).
  3. Låt LUIS extrahera innebörden från sändningsinformationen, som analyseras, och försök att fastställa avsikten med användarens begäran kommer att göras.

Utveckling omfattar skapandet av 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ändningen av rörelsekontrollanter 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 din 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 ditt mixed reality-program.

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

Stöd för enheter

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

Anteckning

Den här kursen fokuserar främst på Windows Mixed Reality integrerande (VR) headset, men du kan också använda det du lär dig i den här kursen för att Microsoft HoloLens. När du följer kursen visas anteckningar om eventuella ändringar som du kan behöva använda för att stödja HoloLens. När du använder HoloLens kan det hända att du ser eko under röstinspelningen.

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 kraven och de skriftliga instruktionerna i det här dokumentet representerar vad som har testats och verifierats i skrivande stund (maj 2018). Du är fri att använda den senaste programvaran, som anges i artikeln installera verktyg , men det bör inte antas att informationen i den här kursen kommer att matcha perfekt vad du hittar i nyare programvara än vad som anges nedan.

Vi rekommenderar följande maskinvara 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 rotmapp (långa mappsökvägar kan orsaka problem vid byggtiden).

  2. Om du vill att datorn ska kunna aktivera diktering går du till Windows Inställningar > Sekretesstal>, Pennanteckningsskrivning & och trycker på knappen Aktivera taltjänster och skriver förslag.

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

  4. Om headsetet har en inbyggd mikrofon kontrollerar du att alternativet "När jag använder mitt headset, byt till headsetmikrofon" är aktiverat i inställningarna för Mixed Reality-portalen.

    Setting up immersive headset

Kapitel 1 – Konfigurera Azure-portalen

Om du vill använda 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-portalen.

    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 en labbsituation ber du din lärare eller någon av rektorerna 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.

    Create LUIS resource

    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.

    LUIS service creation - legal notice

  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 en kostnadsfri nivå (med namnet F0) vara tillgänglig för dig. 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 artikeln om resursgrupper.

    5. Fastställ platsen för resursgruppen (om du skapar en ny resursgrupp). Platsen skulle helst finnas 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 villkor som tillämpas på den här tjänsten.

    7. Välj Skapa.

      Create LUIS service - user input

  5. När du har klickat på 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.

    New Azure notification image

  7. Klicka på meddelandet för att utforska din nya tjänstinstans.

    Successful resource creation notification

  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.

    Accessing LUIS Keys

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

  10. Från sidan Snabbstart i LUIS API-tjänsten navigerar du till det första steget, Hämtar dina nycklar och klickar på Nycklar (du kan också uppnå detta genom att klicka på den blå hyperlänken Nycklar, som finns i navigeringsmenyn för tjänster, som anges av nyckelikonen). Då visas tjänstnycklarna.

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

  12. På sidan Tjänst klickar du på Language Understanding-portalen för att omdirigeras till den webbsida som du ska 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 skapar en LUIS-app på LUIS-portalen.

Viktigt

Tänk på att konfigurationen av entiteter, avsikter och yttranden i det här kapitlet bara är det första steget när du skapar LUIS-tjänsten. Du måste också träna om tjänsten flera gånger så att den blir mer exakt. Omträning av tjänsten beskrivs 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 din Azure Portal.

    LUIS login page

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

    Create LUIS app page

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

    LUIS - my apps image

  4. Ge appen ett namn.

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

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

    LUIS - create a new app

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

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

    • Avsikt, representerar den metod som ska 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.
    • Talindata är exempel på frågor som tillhandahålls av utvecklaren och som LUIS använder för att träna sig själv.

Om dessa begrepp inte är helt tydliga, oroa dig inte, eftersom den här kursen kommer att klargöra dem ytterligare i detta kapitel.

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å Entiteter och sedan på Skapa ny entitet.

    Create new entity

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

    Create simple entity - color

  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:

Result of entity creation

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

    Create new intents

  2. Anropa den nya avsiktsändringenObjectColor.

    Viktigt

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

När du har bekräftat namnet dirigeras du till sidan Avsikter.

LUIS - intents page

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 yttrande 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 yttrandet visas i en lista under.

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 yttrande 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ärg entitet och all möjlig referens till ett mål som en målentitet .

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

    Identify Utterance Targets

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

    Identify Utterance Entities

  3. Märk nästa rad också, där kuben ska vara ett mål, och svart ska vara en färg. Observera även 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 enstaka ord klickar du bara på dem.
    • Om du vill ha en uppsättning med två eller flera 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 se ut som i bilderna nedan, som visar vyn Entiteter/token:

    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.

    Train LUIS

  7. Som en övning för dig skapar du en ny avsikt med namnet ChangeObjectSize med hjälp av entitetsmålet, upp- och nedstorlek.

  8. Efter samma process som föregående avsikt 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 likna det i bilden nedan:

    Setup the ChangeObjectSize Tokens/ Entities

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

    Publish LUIS service

  11. På sidan Publicera kommer du att slutföra och publicera luis-appen så att den kan nås av din kod.

    1. Ange listrutan Publish To (Publicera till ) som Production (Produktion).

    2. Ange tidszonen till din tidszon.

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

    4. Klicka på Publicera till produktionsplats.

      Publish Settings

  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-element nedan och ignorerar det.
    3. Klicka på Lägg till nyckel och infoga nyckeln som du fick i Azure-portalen när du skapade tjänstinstansen. Om azure- och LUIS-portalen är inloggade på samma användare får du listrutor för klientnamn, prenumerationsnamn och den nyckel som du vill använda (har samma namn som du angav tidigare i Azure-portalen.

    Viktigt

    Under Slutpunkten 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 konfiguration 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.

    Start new Unity project.

  2. Nu måste du ange ett Unity-Project namn och infoga MR_LUIS. Kontrollera att projekttypen är inställd på 3D. Ange plats till någonstans som passar dig (kom ihåg att närmare rotkataloger är bättre). Klicka sedan på Skapa projekt.

    Provide details for new Unity project.

  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 .

    Update script editor preference.

  4. Gå sedan till File > Build Inställningar och växla plattformen till Universell Windows-plattform genom att klicka på knappen Växla plattform.

    Build Settings window, switch platform to UWP.

  5. Gå till File > Build 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 är inställd på D3D

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

    4. Visual Studio version har angetts till Senaste installerad

    5. Build and Run ä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 spara-fönster visas.

        Click add open scenes button

      2. Skapa en ny mapp för detta och eventuell framtida scen och välj sedan knappen Ny mapp för att skapa en ny mapp och ge den namnet Scener.

        Create new scripts folder

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

        Give new scene a name.

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

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

    Open player settings.

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

    1. På fliken Annat Inställningar:

      1. Körningsversionen för skript ska vara stabil (.NET 3.5 Motsvarande).

      2. Skriptserverdelen ska vara .NET

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

        Update other settings.

    2. På fliken Publicering Inställningar går du till Funktioner och kontrollerar:

      1. InternetClient

      2. Mikrofon

        Updating publishing settings.

    3. Längre ned på 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.

      Update the X R Settings.

  8. Tillbaka i Build InställningarUnity C# Projects is not longer greyed out (Skapa Inställningar Unity C#-projekt är inte längre nedtonat). Markera kryssrutan bredvid detta.

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

  10. Spara scen och Project (FIL > SPARA SCEN/FIL > SPARA PROJEKT).

Kapitel 4 – Skapa scenen

Viktigt

Om du vill hoppa över unity-konfigurationskomponenten i den här kursen och fortsätta direkt i koden kan du ladda ned .unitypackage, importera den till ditt projekt som ett anpassat paket och sedan fortsätta från kapitel 5.

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

    Create a plane.

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

  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 likna den i bilden nedan:

    Scene Hierarchy setup.

  5. Vänsterklicka på huvudkameran för att välja den. Titta på Kontrollpanelen där du ser kameraobjektet med alla dess komponenter.

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

    Add Audio Source

  7. Sök efter komponenten med namnet Ljudkälla enligt ovan.

  8. Kontrollera också att transformeringskomponenten i huvudkameran är inställd på (0,0,0), detta kan göras 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. Rotationen är inställd 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:

    • Ta bort flaggor: Enfärgad.
    • Bakgrund "Black, Alpha 0" – Hexfärg: #000000000.
  9. Vänsterklicka på Planet för att välja 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 markera 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

X Y Z
0 1 4

Transformera – rotation

X Y Z
45 45 0
  1. Vänsterklicka på objektet Ny text för att markera det. I Kontrollpanelen anger du transformeringskomponenten med följande värden:

Transformera – position

X Y Z
-2 6 9

Transformera – skala

X Y Z
0.1 0.1 0.1
  1. Ändra Teckenstorlek i komponenten Text Mesh till 50.

  2. Ändra namnetobjektet Text Mesh till Dikteringstext.

    Create 3D Text object

  3. Hierarkipanelens struktur bör nu se ut så här:

    text mesh in scene view

  4. Slutscenen bör se ut som på bilden nedan:

    The scene view.

Kapitel 5 – Skapa klassen MicrophoneManager

Det första skriptet som du ska skapa är klassen MicrophoneManager . Efter det här skapar du LuisManager, klassen Behaviors och slutligen klassen Gaze (skapa alla dessa nu, även om det kommer att täckas när du når varje kapitel).

Klassen MicrophoneManager ansvarar för:

  • Identifiera inspelningsenheten som är ansluten till headsetet eller datorn (beroende på vilket som är standard).
  • Spela 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 dikteringen till klassen LuisManager .

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

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

    Create Scripts folder.

  2. När mappen Skript har skapats dubbelklickar du på den för att öppna. Högerklicka sedan på Skapa > C#-skript i mappen. 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. Kod för metoderna Awake() och Start() måste nu läggas till. Dessa anropas när klassen initieras:

        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östinspelningen och skicka den till LuisManager-klassen som du kommer att skapa snart.

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

        /// <summary>
        /// This handler is called every time the Dictation detects a pause in the speech. 
        /// This method will stop listening for audio, send a request to the LUIS service 
        /// and then start listening again.
        /// </summary>
        private void DictationRecognizer_DictationResult(string dictationCaptured, ConfidenceLevel confidence)
        {
            StopCapturingAudio();
            StartCoroutine(LuisManager.instance.SubmitRequestToLuis(dictationCaptured, StartCapturingAudio));
            Debug.Log("Dictation: " + dictationCaptured);
            dictationText.text = dictationCaptured;
        }
    
        private void DictationRecognizer_DictationError(string error, int hresult)
        {
            Debug.Log("Dictation exception: " + error);
        }
    

    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 återvänder till Unity.

    Anteckning

    Nu ser du ett fel som visas i Konsolpanelen för Unity-redigeraren. Det beror på att koden refererar till den LuisManager-klass som du skapar i nästa kapitel.

Kapitel 6 – Skapa LUISManager-klassen

Det är dags för dig att skapa klassen LuisManager , 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 som ska analyseras.

Den här klassen deserialiserar JSON-svaret och anropar lämpliga metoder i klassen Behaviours 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 iLuisManager-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 klassen LuisManager :

        public static LuisManager instance;
    
        //Substitute the value of luis Endpoint with your own End Point
        string luisEndpoint = "https://westus.api.cognitive... add your endpoint from the Luis Portal";
    
  7. Se till att placera luis-slutpunkten i nu (som du kommer att ha från LUIS-portalen).

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

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  9. Nu behöver du de metoder som programmet använder för att skicka diktamen 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 AnalyseResponseElements() som läser den resulterande AnalysedQuery och fastställer entiteterna. När entiteterna har fastställts skickas de till instansen av klassen Beteenden 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 använder dem.

  12. Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Anteckning

Nu ser du flera fel som visas i Konsolpanelen för Unity-redigeraren. Det beror på att koden refererar till klassen Behaviours som du skapar i nästa kapitel.

Kapitel 7 – Skapa klassen Behaviours

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

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. Namnge skriptets beteenden.

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

  4. Lägg sedan till följande variabler i klassen Behaviours :

        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 initieras:

        void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  6. Följande metoder anropas av klassen LuisManager (som du har skapat 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 för att GameObject ska "bevakas" om inget explicit mål definieras 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 använder dem.

  8. Se till att spara ändringarna i Visual Studio innan du återvänder till Unity.

Kapitel 8 – Skapa Gaze-klassen

Den sista klassen som du behöver för att slutföra den här appen är klassen Gaze . 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 Gaze.

  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 återvänder till Unity.

Kapitel 9 – Slutföra scenkonfigurationen

  1. Om du vill slutföra installationen av scenen drar du varje skript som du har skapat från mappen Skript till huvudkameraobjektethierarkipanelen.

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

    Setting the Camera Reference Targets.

  3. Följ dessa anvisningar om du vill ange dessa parametrar korrekt:

    1. MicrophoneManager:

      • Dra objektet Dikteringstext från hierarkipanelen till parametervärderutan Dikteringstext.
    2. Beteenden från hierarkipanelen:

      • Dra Sphere-objektet till målrutan Sphere-referens .
      • Dra cylindern till målrutan Cylinderreferens .
      • Dra kuben till målrutan Kubreferens .
    3. Blick:

      • Ange maxavståndet för Gaze till 300 (om det inte redan är det).
  4. Resultatet bör se ut som bilden nedan:

    Showing the Camera Reference Targets, now set.

Kapitel 10 – Testa i Unity-redigeraren

Testa att scenkonfigurationen är korrekt implementerad.

Se till att du har gjort följande:

  • Alla skript är anslutna till huvudkameraobjektet .
  • Alla fält i huvudpanelen för kamerakontroll tilldelas korrekt.
  1. Tryck på knappen Spela upp i Unity-redigeraren. Appen ska köras i det anslutna uppslukande 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. Detta beror på hur mixed reality-portalen hanterar inbyggda mikrofoner för headset som har dem. Om du ser det här felet stoppar du helt enkelt scenen och startar den igen och saker och ting bör fungera som förväntat.

Kapitel 11 – Skapa och separat läsa in UWP-lösningen

När du har kontrollerat 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å Spara fil>.

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

  3. Markera kryssrutan Unity C# Projects (användbart för att se och felsöka koden när UWP-projektet har skapats.

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

    Build Settings window

  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 valfritt namn.

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

    Create Builds FolderSelect Builds Folder

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

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

  1. I Visual Studio öppnar 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 lättare att ställa in detta på Fjärrdator, så att du inte är bunden till datorn. Men du måste också göra följande:

    • Ta reda på IP-adressen för din HoloLens, som finns i Inställningar > Network & Internet > Wi-Fi > Avancerade alternativ. IPv4 är den adress som du bör använda.
    • Se till att utvecklarläget är ; finns i Inställningar > Uppdateringssäkerhet &> för utvecklare.

    Deploy App

  4. Gå till menyn Skapa och klicka på Distribuera lösning för att läsa in programmet separat på datorn.

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

  6. När appen har startats uppmanas du att auktorisera åtkomst till mikrofonen. Använd rörelsestyrenheterna, röstinmatningen eller tangentbordet för att trycka på JA-knappen .

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

Viktigt

Det här kapitlet är oerhört viktigt och kan behöva itereras flera gånger, eftersom det bidrar till att förbättra precisionen för LUIS-tjänsten: se till att du slutför det här.

För att förbättra den förståelsenivå som tillhandahålls av LUIS måste du samla in nya yttranden och använda dem för att träna om luis-appen.

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

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

  1. Gå till portalprogrammet efter den här LÄNKEN och 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.

    Review Utterances

  4. Du visas en lista över yttranden som har skickats till LUIS av ditt mixed reality-program.

    List of Utterances

Du kommer att märka några markerade entiteter.

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

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

Check utterancesRemove Label Image

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

    Delete wrong utterances

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

    Add to aligned intent

  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 fler är tillgängliga.

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

Ha det så kul!

Ditt färdiga LUIS-integrerade program

Grattis! Du har skapat en mixed reality-app som använder Azure Language Understanding Intelligence Service för att förstå vad en användare säger och agera utifrån den informationen.

Lab outcome

Bonusövningar

Övning 1

När du använder det här programmet kanske du märker att om du tittar på floor-objektet och ber om att ändra dess färg, kommer det att göra det. Kan du komma på hur du kan stoppa programmet från att ändra golvfärgen?

Övning 2

Prova att utöka luis- och appfunktionerna och lägga till ytterligare funktioner för objekt i scenen. Som exempel kan du skapa nya objekt vid Träffpunkten för Blick, beroende på vad användaren säger, och sedan kunna använda dessa objekt tillsammans med aktuella scenobjekt med de befintliga kommandona.