Urządzenia HoloLens (1. generacji) i Azure 303: rozpoznawanie języka naturalnego (LUIS)

Uwaga

Samouczki Mixed Reality Academy zostały zaprojektowane z myślą o urządzeniach HoloLens (1. generacji) i Mixed Reality immersywnych zestawów słuchawkowych. W związku z tym uważamy, że ważne jest pozostawienie tych samouczków w miejscu dla deweloperów, którzy nadal szukają wskazówek dotyczących opracowywania dla tych urządzeń. Te samouczki nie zostaną zaktualizowane o najnowsze zestawy narzędzi ani interakcje używane na potrzeby HoloLens 2. Będą one utrzymywane w celu kontynuowania pracy na obsługiwanych urządzeniach. W przyszłości zostanie opublikowana nowa seria samouczków, które pokażą, jak opracowywać na potrzeby HoloLens 2. To powiadomienie zostanie zaktualizowane za pomocą linku do tych samouczków po ich opublikowaniu.

Z tego kursu dowiesz się, jak zintegrować Language Understanding z aplikacją rzeczywistości mieszanej przy użyciu usług Azure Cognitive Services z interfejsem API Language Understanding.

Language Understanding (LUIS) to usługa platformy Microsoft Azure, która zapewnia aplikacjom możliwość tworzenia znaczenia z danych wejściowych użytkownika, takich jak wyodrębnianie tego, czego może chcieć dana osoba, w swoich słowach. Jest to realizowane za pomocą uczenia maszynowego, które rozumie i uczy się informacji wejściowych, a następnie może odpowiedzieć za pomocą szczegółowych, istotnych informacji. Aby uzyskać więcej informacji, odwiedź stronę usługi Azure Language Understanding (LUIS).

Po ukończeniu tego kursu będziesz mieć aplikację immersywną rzeczywistości mieszanej, która będzie mogła wykonać następujące czynności:

1. Przechwyć mowę wejściową użytkownika przy użyciu mikrofonu dołączonego do immersywnego zestawu nagłownego.
2. Wyślij przechwycone dyktowanie w usłudze Azure Language Understanding Intelligent Service (LUIS).
3. Poproś usługę LUIS o wyodrębnienie znaczenia z informacji o wysyłaniu, które zostaną przeanalizowane, i podjęcie próby określenia intencji żądania użytkownika.

Programowanie będzie obejmować tworzenie aplikacji, w której użytkownik będzie mógł używać głosu i/lub spojrzenia w celu zmiany rozmiaru i koloru obiektów w scenie. Korzystanie z kontrolerów ruchu nie będzie objęte.

W aplikacji należy do Ciebie, jak zintegrować wyniki z projektem. Ten kurs jest przeznaczony do nauki integrowania usługi platformy Azure z projektem aparatu Unity. Twoim zadaniem jest wykorzystanie wiedzy zdobytą z tego kursu w celu ulepszenia aplikacji rzeczywistości mieszanej.

Przygotuj się na szkolenie usługi LUIS kilka razy, co zostało omówione w rozdziale 12. Uzyskasz lepsze wyniki, tym więcej razy usługa LUIS została wytrenowana.

Obsługa urządzeń

Kurs	HoloLens	Immersyjne zestawy nagłowne
MR i Azure 303: Rozpoznawanie języka naturalnego (LUIS)	✔️	✔️

Uwaga

Chociaż ten kurs koncentruje się głównie na Windows Mixed Reality immersywnych zestawach słuchawkowych (VR), możesz również zastosować to, czego uczysz się w tym kursie, aby Microsoft HoloLens. Wraz z kursem zobaczysz notatki dotyczące wszelkich zmian, które mogą być konieczne do zastosowania w celu obsługi urządzenia HoloLens. Podczas korzystania z urządzenia HoloLens można zauważyć pewne echo podczas przechwytywania głosu.

Wymagania wstępne

Uwaga

Ten samouczek jest przeznaczony dla deweloperów, którzy mają podstawowe doświadczenie w językach Unity i C#. Należy również pamiętać, że wymagania wstępne i pisemne instrukcje zawarte w tym dokumencie reprezentują to, co zostało przetestowane i zweryfikowane w momencie pisania (maj 2018 r.). Możesz korzystać z najnowszego oprogramowania, jak wymieniono w artykule dotyczącym instalacji narzędzi , choć nie należy zakładać, że informacje w tym kursie doskonale pasują do tego, co znajdziesz w nowszym oprogramowaniu niż wymienione poniżej.

Na potrzeby tego kursu zalecamy następujący sprzęt i oprogramowanie:

• Komputer deweloperów, zgodny z Windows Mixed Reality na potrzeby opracowywania immersywnych zestawów słuchawkowych (VR)
• Windows 10 Fall Creators Update (lub nowszy) z włączonym trybem dewelopera
• Najnowszy zestaw SDK Windows 10
• Unity 2017.4
• Visual Studio 2017
• Zestaw słuchawkowy Windows Mixed Reality immersywny (VR) lub Microsoft HoloLens z włączonym trybem dewelopera
• Zestaw słuchawek z wbudowanym mikrofonem (jeśli zestaw słuchawkowy nie ma wbudowanego mikrofonu i głośników)
• Dostęp do Internetu na potrzeby instalacji platformy Azure i pobierania usługi LUIS

Przed rozpoczęciem

1. Aby uniknąć problemów podczas tworzenia tego projektu, zdecydowanie zaleca się utworzenie projektu wymienionego w tym samouczku w folderze głównym lub niemal głównym (długie ścieżki folderów mogą powodować problemy w czasie kompilacji).

2. Aby zezwolić maszynie na włączanie dyktowania, przejdź do pozycji Ustawienia >> systemu Windows Prywatność mowa, & pisanie odręczne i naciśnij przycisk Włącz usługi mowy i sugestie pisania.

3. Kod w tym samouczku umożliwi nagrywanie z domyślnego urządzenia mikrofonu ustawionego na maszynie. Upewnij się, że domyślne urządzenie mikrofonu jest ustawione jako urządzenie, którego chcesz użyć do przechwytywania głosu.

4. Jeśli zestaw słuchawkowy ma wbudowany mikrofon, upewnij się, że opcja "Gdy nosim zestaw słuchawkowy, przełącznik do mikrofonu nagłownego" jest włączona w ustawieniach portalu Mixed Reality.

   

Rozdział 1 — Konfigurowanie witryny Azure Portal

Aby korzystać z usługi Language Understanding na platformie Azure, należy skonfigurować wystąpienie usługi, aby było dostępne dla aplikacji.

1. Zaloguj się do witryny Azure Portal.

   Uwaga

   Jeśli nie masz jeszcze konta platformy Azure, musisz je utworzyć. Jeśli korzystasz z tego samouczka w sytuacji na potrzeby zajęć lub laboratorium, poproś instruktora lub jednego z opiekunów o pomoc przy konfigurowaniu nowego konta.

2. Po zalogowaniu kliknij pozycję Nowy w lewym górnym rogu i wyszukaj Language Understanding, a następnie kliknij przycisk Enter.

   

   Uwaga

   Wyraz Nowy mógł zostać zastąpiony ciągiem Create a resource (Utwórz zasób) w nowszych portalach.

3. Nowa strona po prawej stronie zawiera opis usługi Language Understanding. W lewym dolnym rogu tej strony wybierz przycisk Utwórz , aby utworzyć wystąpienie tej usługi.

   

4. Po kliknięciu pozycji Utwórz:

   1. Wstaw żądaną nazwę dla tego wystąpienia usługi.

   2. Wybierz subskrypcję.

   3. Wybierz warstwę cenową odpowiednią dla Ciebie, jeśli po raz pierwszy utworzysz usługę LUIS, powinna być dostępna warstwa bezpłatna (o nazwie F0). Bezpłatna alokacja powinna być większa niż wystarczająca dla tego kursu.

   4. Wybierz grupę zasobów lub utwórz nową. Grupa zasobów umożliwia monitorowanie, kontrolowanie dostępu, aprowizowania i zarządzania rozliczeniami dla kolekcji zasobów platformy Azure. Zaleca się przechowywanie wszystkich usług platformy Azure skojarzonych z pojedynczym projektem (np. takimi jak te kursy) w ramach wspólnej grupy zasobów.

      Jeśli chcesz dowiedzieć się więcej na temat grup zasobów platformy Azure, odwiedź artykuł grupy zasobów.

   5. Określ lokalizację grupy zasobów (jeśli tworzysz nową grupę zasobów). Lokalizacja najlepiej będzie znajdować się w regionie, w którym będzie uruchamiana aplikacja. Niektóre zasoby platformy Azure są dostępne tylko w niektórych regionach.

   6. Musisz również potwierdzić, że rozumiesz warunki i postanowienia zastosowane do tej usługi.

   7. Wybierz przycisk Utwórz.

      

5. Po kliknięciu pozycji Utwórz trzeba będzie poczekać na utworzenie usługi. Może to potrwać minutę.

6. Po utworzeniu wystąpienia usługi w portalu zostanie wyświetlone powiadomienie.

   

7. Kliknij powiadomienie, aby zapoznać się z nowym wystąpieniem usługi.

   

8. Kliknij przycisk Przejdź do zasobu w powiadomieniu, aby zapoznać się z nowym wystąpieniem usługi. Nastąpi przekierowanie do nowego wystąpienia usługi LUIS.

   

9. W ramach tego samouczka aplikacja będzie musiała wykonywać wywołania usługi, co odbywa się za pomocą klucza subskrypcji usługi.

10. Na stronie Szybki start usługi INTERFEJS API usługi LUIS przejdź do pierwszego kroku, pobierz klucze i kliknij pozycję Klucze (możesz to również osiągnąć, klikając niebieskie hiperlinki Klucze, znajdujące się w menu nawigacji usług, oznaczone ikoną klucza). Spowoduje to wyświetlenie kluczy usługi.

11. Pobierz kopię jednego z wyświetlanych kluczy, ponieważ będzie to potrzebne w dalszej części projektu.

12. Na stronie Usługa kliknij pozycję Language Understanding Portal, aby zostać przekierowany do strony internetowej, której użyjesz do utworzenia nowej usługi w aplikacji usługi LUIS.

Rozdział 2 — portal Language Understanding

W tej sekcji dowiesz się, jak utworzyć aplikację usługi LUIS w portalu usługi LUIS.

Ważne

Należy pamiętać, że skonfigurowanie jednostek,intencji i wypowiedzi w tym rozdziale jest tylko pierwszym krokiem tworzenia usługi LUIS: należy również ponownie trenować usługę, kilka razy, aby zwiększyć jej dokładność. Ponowne trenowanie usługi zostało omówione w ostatnim rozdziale tego kursu, dlatego upewnij się, że została ukończona.

1. Po dotarciu do portalu Language Understanding może być konieczne zalogowanie się, jeśli jeszcze tego nie zrobiono, przy użyciu tych samych poświadczeń co Azure Portal.

   

2. Jeśli używasz usługi LUIS po raz pierwszy, musisz przewinąć w dół do dołu strony powitalnej, aby znaleźć i kliknąć przycisk Utwórz aplikację usługi LUIS .

   

3. Po zalogowaniu kliknij pozycję Moje aplikacje (jeśli nie jesteś obecnie w tej sekcji). Następnie możesz kliknąć pozycję Utwórz nową aplikację.

   

4. Nadaj aplikacji nazwę.

5. Jeśli aplikacja powinna rozumieć język inny niż angielski, należy zmienić kulturę na odpowiedni język.

6. W tym miejscu możesz również dodać opis nowej aplikacji usługi LUIS.

   

7. Po naciśnięciu przycisku Gotowe wprowadź stronę Kompilacja nowej aplikacji LUIS .

8. Istnieje kilka ważnych pojęć, które należy zrozumieć tutaj:

   • Intencja reprezentuje metodę, która będzie wywoływana po zapytaniu od użytkownika. Intencja może mieć co najmniej jedną jednostkę.
   • Jednostka jest składnikiem zapytania opisującego informacje istotne dla intencji.
   • Wypowiedzi to przykłady zapytań dostarczonych przez dewelopera, których usługa LUIS będzie używać do trenowania.

Jeśli te pojęcia nie są całkowicie jasne, nie martw się, ponieważ ten kurs wyjaśni je dalej w tym rozdziale.

Rozpoczniesz od utworzenia jednostek potrzebnych do utworzenia tego kursu.

9. Po lewej stronie kliknij pozycję Jednostki, a następnie kliknij pozycję Utwórz nową jednostkę.

   

10. Wywołaj nowy kolor jednostki, ustaw jego typ na Prosty, a następnie naciśnij przycisk Gotowe.

    

11. Powtórz ten proces, aby utworzyć trzy (3) więcej jednostek prostych o nazwie:

    • Rozbudować
    • downsize
    • Docelowego

Wynik powinien wyglądać podobnie do poniższego obrazu:

W tym momencie możesz rozpocząć tworzenie intencji.

Ostrzeżenie

Nie usuwaj intencji None .

12. Po lewej stronie kliknij pozycję Intents (Intencje), a następnie kliknij pozycję Create new intent (Utwórz nową intencję).

    

13. Wywołaj nową intencjęChangeObjectColor.

    Ważne

    Ta nazwa intencji jest używana w kodzie w dalszej części tego kursu, dlatego w celu uzyskania najlepszych wyników użyj tej nazwy dokładnie tak, jak podano.

Po potwierdzeniu nazwy nastąpi przekierowanie do strony Intencje.

Zauważysz, że istnieje pole tekstowe z prośbą o wpisanie co najmniej 5 różnych wypowiedzi.

Uwaga

Usługa LUIS konwertuje wszystkie wypowiedzi na małe litery.

14. Wstaw następującą wypowiedź w górnym polu tekstowym (obecnie z tekstem Wpisz około 5 przykładów... ) i naciśnij klawisz Enter:

The color of the cylinder must be red

Zauważysz, że nowa wypowiedź będzie wyświetlana na liście poniżej.

Po wykonaniu tego samego procesu wstaw następujące sześć (6) wypowiedzi:

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

Dla każdej utworzonej wypowiedzi należy określić, które słowa powinny być używane przez usługę LUIS jako jednostki. W tym przykładzie należy oznaczyć wszystkie kolory jako jednostkę koloru i wszystkie możliwe odwołania do elementu docelowego jako jednostkę docelową .

15. W tym celu spróbuj kliknąć wyraz cylinder w pierwszej wypowiedzi i wybrać element docelowy.

    

16. Teraz kliknij wyraz czerwony w pierwszej wypowiedzi i wybierz kolor.

    

17. Etykietuj również następny wiersz, gdzie moduł powinien być elementem docelowym, a czarny powinien być kolorem. Zwróć również uwagę na użycie wyrazów "this", "it" i "this object", które udostępniamy, tak aby nie było dostępnych również określonych typów docelowych.

18. Powtórz powyższy proces, aż wszystkie wypowiedzi mają etykietę Jednostki. Jeśli potrzebujesz pomocy, zapoznaj się z poniższym obrazem.

    Porada

    Podczas wybierania wyrazów, aby oznaczyć je jako jednostki:

    • W przypadku pojedynczych wyrazów wystarczy je kliknąć.
    • W przypadku zestawu co najmniej dwóch wyrazów kliknij na początku, a następnie na końcu zestawu.

    Uwaga

    Możesz użyć przycisku przełączania Widok tokenów , aby przełączać się między widokami jednostek/tokenów!

19. Wyniki powinny być widoczne na poniższych ilustracjach, pokazując widok Jednostki/tokeny:

    

20. W tym momencie naciśnij przycisk Train (Trenuj ) w prawym górnym rogu strony i poczekaj, aż mały okrągły wskaźnik na nim będzie zielony. Oznacza to, że usługa LUIS została pomyślnie wytrenowana do rozpoznawania tej intencji.

    

21. W ramach ćwiczenia utwórz nową intencję o nazwie ChangeObjectSize przy użyciu obiektu docelowego Entities, upsize i downsize.

22. Po wykonaniu tego samego procesu co poprzednia intencja wstaw następujące osiem (8) wypowiedzi dla zmiany rozmiaru :

    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
    

23. Wynik powinien przypominać ten na poniższej ilustracji:

    

24. Po utworzeniu i wytrenowaniu obu intencji , ChangeObjectColor i ChangeObjectSize kliknij przycisk PUBLIKUJ w górnej części strony.

    

25. Na stronie Publikowanie opublikujesz i opublikujesz aplikację usługi LUIS, aby można było uzyskać do niej dostęp za pomocą kodu.

    1. Ustaw listę rozwijaną Publikuj do jako środowisko produkcyjne.

    2. Ustaw strefę czasową na strefę czasową.

    3. Zaznacz pole wyboru Uwzględnij wszystkie przewidywane wyniki intencji.

    4. Kliknij pozycję Publikuj w miejscu produkcyjnym.

       

26. W sekcji Zasoby i klucze:

    1. Wybierz region ustawiony dla wystąpienia usługi w witrynie Azure Portal.
    2. Zauważysz Starter_Key element poniżej, zignoruj go.
    3. Kliknij pozycję Dodaj klucz i wstaw klucz uzyskany w witrynie Azure Portal podczas tworzenia wystąpienia usługi. Jeśli platforma Azure i portal usługi LUIS są rejestrowane w tym samym użytkowniku, zostaną wyświetlone menu rozwijane dla pola Nazwa dzierżawy, Nazwa subskrypcji i Klucz , którego chcesz użyć (będzie mieć taką samą nazwę, jak podano wcześniej w witrynie Azure Portal.

    Ważne

    W obszarze Punkt końcowy utwórz kopię punktu końcowego odpowiadającego wstawionemu kluczowi. Wkrótce użyjesz go w kodzie.

Rozdział 3 — Konfigurowanie projektu aparatu Unity

Poniżej przedstawiono typową konfigurację do opracowywania za pomocą rzeczywistości mieszanej, a w związku z tym jest to dobry szablon dla innych projektów.

1. Otwórz aparat Unity i kliknij pozycję Nowy.

   

2. Teraz musisz podać nazwę projektu aparatu Unity, wstawić MR_LUIS. Upewnij się, że typ projektu jest ustawiony na wartość 3D. Ustaw lokalizację na odpowiednią dla Siebie (pamiętaj, że bliżej katalogów głównych jest lepiej). Następnie kliknij pozycję Utwórz projekt.

   

3. Po otwarciu aparatu Unity warto sprawdzić, czy domyślny edytor skryptów jest ustawiony na program Visual Studio. Przejdź do pozycji Edytuj > preferencje, a następnie w nowym oknie przejdź do pozycji Narzędzia zewnętrzne. Zmień edytor skryptów zewnętrznych na Visual Studio 2017. Zamknij okno Preferencje .

   

4. Następnie przejdź do pozycji Ustawienia kompilacji plików > i przełącz platformę na platforma uniwersalna systemu Windows, klikając przycisk Przełącz platformę.

   

5. Przejdź do pozycji Ustawienia kompilacji pliku > i upewnij się, że:

   1. Urządzenie docelowe jest ustawione na dowolne urządzenie

      W przypadku Microsoft HoloLens ustaw wartość Urządzenie docelowe na HoloLens.

   2. Typ kompilacji jest ustawiony na D3D

   3. Zestaw SDK jest ustawiony na najnowszą zainstalowaną

   4. Wersja programu Visual Studio jest ustawiona na najnowszą zainstalowaną

   5. Kompilowanie i uruchamianie jest ustawione na komputer lokalny

   6. Zapisz scenę i dodaj ją do kompilacji.

      1. Zrób to, wybierając pozycję Dodaj otwarte sceny. Zostanie wyświetlone okno zapisywania.

         

      2. Utwórz nowy folder dla tego i dowolnego przyszłego sceny, a następnie wybierz przycisk Nowy folder , aby utworzyć nowy folder, nadaj mu nazwę Sceny.

         

      3. Otwórz nowo utworzony folder Sceny , a następnie w polu Nazwa pliku: tekst wpisz MR_LuisScene, a następnie naciśnij przycisk Zapisz.

         

   7. Pozostałe ustawienia w obszarze Ustawienia kompilacji powinny być pozostawione jako domyślne na razie.

6. W oknie Ustawienia kompilacji kliknij przycisk Ustawienia odtwarzacza , spowoduje to otwarcie powiązanego panelu w obszarze, w którym znajduje się inspektor .

   

7. W tym panelu należy zweryfikować kilka ustawień:

   1. Na karcie Inne ustawienia :

      1. Wersja środowiska uruchomieniowego skryptów powinna być stabilna (odpowiednik platformy.NET 3.5).

      2. Zaplecze skryptów powinno mieć wartość .NET

      3. Poziom zgodności interfejsu API powinien mieć wartość .NET 4.6

         

   2. Na karcie Ustawienia publikowania w obszarze Możliwości sprawdź:

      1. InternetClient

      2. Mikrofon

         

   3. W dalszej części panelu w obszarze Ustawienia XR (znajdujące się poniżej ustawień publikowania) zaznacz opcję Virtual Reality Supported (Obsługa rzeczywistości wirtualnej), upewnij się, że dodano zestaw SDK Windows Mixed Reality.

      

8. W obszarze Ustawienia kompilacji Projekty aparatu Unity C# nie są już wyszarzone; zaznacz pole wyboru obok tego.

9. Zamknij okno Build Settings (Ustawienia kompilacji).

10. Zapisz scenę i projekt (PLIK > ZAPISZ SCENĘ / PLIK > ZAPISZ PROJEKT).

Rozdział 4 — Tworzenie sceny

Ważne

Jeśli chcesz pominąć składnik Unity Set up tego kursu i kontynuować bezpośrednio w kodzie, możesz pobrać ten pakiet unitypackage, zaimportować go do projektu jako pakiet niestandardowy, a następnie kontynuować z rozdziału 5.

1. Kliknij prawym przyciskiem myszy pusty obszar panelu hierarchii w obszarze Obiekt 3D, dodaj płaszczyznę.

   

2. Należy pamiętać, że po ponownym kliknięciu prawym przyciskiem myszy w hierarchii , aby utworzyć więcej obiektów, jeśli nadal wybrano ostatni obiekt, wybrany obiekt będzie elementem nadrzędnym nowego obiektu. Unikaj tego kliknięcia po lewej stronie w pustym miejscu w hierarchii, a następnie kliknij prawym przyciskiem myszy.

3. Powtórz poniższą procedurę, aby dodać następujące obiekty:

   1. Kula
   2. Cylinder
   3. Sześcian
   4. Tekst 3D

4. Wynikowa hierarchia sceny powinna być podobna do tej na poniższej ilustracji:

   

5. Kliknij prawym przyciskiem myszy aparat główny , aby go wybrać, spójrz na Panel inspektora , aby wyświetlić obiekt Aparat ze wszystkimi jego składnikami.

6. Kliknij przycisk Dodaj składnik znajdujący się u dołu Panelu inspektora.

   

7. Wyszukaj składnik o nazwie Źródło audio, jak pokazano powyżej.

8. Upewnij się również, że składnik Transform aparatu głównego jest ustawiony na (0,0,0), można to zrobić, naciskając ikonę Koła zębatego obok składnika Przekształcanie aparatu i wybierając pozycję Resetuj. Następnie składnik Transform powinien wyglądać następująco:

   1. Pozycja jest ustawiona na 0, 0, 0.
   2. Obrót jest ustawiony na wartość 0, 0, 0.

   Uwaga

   W przypadku Microsoft HoloLens należy również zmienić następujące elementy, które są częścią składnika Aparat fotograficzny, który znajduje się na głównym aparacie:

   • Wyczyść flagi: Kolor stały.
   • Tle "Czarny, Alfa 0" — kolor szesnastkowy: #00000000.

9. Kliknij pozycję Płaszczyzna po lewej stronie, aby ją wybrać. W Panelu inspektora ustaw składnik Transform z następującymi wartościami:

   Oś X	Oś Y	Osi
   0	-1	0

10. Kliknij prawym przyciskiem myszy pozycję Sphere , aby go wybrać. W Panelu inspektora ustaw składnik Transform z następującymi wartościami:

    Oś X	Oś Y	Osi
    2	1	2

11. Kliknij prawym przyciskiem myszy cylindra , aby go wybrać. W Panelu inspektora ustaw składnik Transform z następującymi wartościami:

    Oś X	Oś Y	Osi
    -2	1	2

12. Kliknij lewym przyciskiem myszy moduł , aby go zaznaczyć. W Panelu inspektora ustaw składnik Transform z następującymi wartościami:

Przekształcanie — położenie

X	Y	Z
0	1	4

Przekształcanie — rotacja

X	Y	Z
45	45	0

13. Kliknij lewym przyciskiem myszy obiekt Nowy tekst , aby go zaznaczyć. W Panelu inspektora ustaw składnik Transform z następującymi wartościami:

Przekształcanie — położenie

X	Y	Z
-2	6	9

Przekształcanie — skalowanie

X	Y	Z
0.1	0.1	0.1

14. Zmień rozmiar czcionki w składniku Siatki tekstu na 50.

15. Zmień nazwę obiektu Usługi Text Mesh na Tekst Dyktowania.

    

16. Struktura Panelu hierarchii powinna teraz wyglądać następująco:

    

17. Ostateczna scena powinna wyglądać podobnie do poniższej ilustracji:

    

Rozdział 5 — tworzenie klasy MicrophoneManager

Pierwszym utworzonym skryptem jest klasa MicrophoneManager . W tym celu utworzysz klasę LuisManager, zachowanie i ostatnio klasę Gaze (możesz utworzyć wszystkie te elementy teraz, choć zostanie ona omówiona w miarę dotarcia do każdego rozdziału).

Klasa MicrophoneManager jest odpowiedzialna za:

• Wykrywanie urządzenia rejestrującego dołączonego do zestawu słuchawkowego lub maszyny (niezależnie od tego, która jest domyślna).
• Przechwyć dźwięk (głos) i użyj dyktowania, aby zapisać go jako ciąg.
• Po wstrzymaniu głosu prześlij dyktowanie do klasy LuisManager .

Aby utworzyć tę klasę:

1. Kliknij prawym przyciskiem myszy panel projektu, utwórz > folder. Wywołaj skrypty folderu.

   

2. Po utworzeniu folderu Scripts kliknij go dwukrotnie, aby go otworzyć. Następnie w tym folderze kliknij prawym przyciskiem myszy pozycję Utwórz > skrypt języka C#. Nadaj skryptowi nazwę MicrophoneManager.

3. Kliknij dwukrotnie pozycję MikrofonManager , aby otworzyć go za pomocą programu Visual Studio.

4. Dodaj następujące przestrzenie nazw na początku pliku:

       using UnityEngine;
       using UnityEngine.Windows.Speech;
   

5. Następnie dodaj następujące zmienne w klasie 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. Należy teraz dodać kod dla metod Awake() i Start( ). Będą one wywoływane, gdy klasa inicjuje:

       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. Teraz potrzebujesz metody używanej przez aplikację do uruchamiania i zatrzymywania przechwytywania głosu oraz przekazywania jej do klasy LuisManager , którą utworzysz wkrótce.

       /// <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. Dodaj procedurę obsługi dyktowania , która zostanie wywołana po wstrzymaniu głosu. Ta metoda przekaże tekst dyktowania do klasy 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);
       }
   

   Ważne

   Usuń metodę Update(), ponieważ ta klasa nie będzie jej używać.

9. Pamiętaj, aby zapisać zmiany w programie Visual Studio przed powrotem do aparatu Unity.

   Uwaga

   W tym momencie zauważysz błąd wyświetlany w panelu konsoli edytora aparatu Unity. Jest to spowodowane tym, że kod odwołuje się do klasy LuisManager , którą utworzysz w następnym rozdziale.

Rozdział 6 — tworzenie klasy LUISManager

Nadszedł czas, aby utworzyć klasę LuisManager , która spowoduje wywołanie usługi Azure LUIS.

Celem tej klasy jest odbieranie tekstu dyktowania z klasy MicrophoneManager i wysyłanie go do interfejsu API usługi Azure Language Understanding do przeanalizowania.

Ta klasa będzie deserializować odpowiedź JSON i wywołać odpowiednie metody klasy Behaviors w celu wyzwolenia akcji.

Aby utworzyć tę klasę:

1. Kliknij dwukrotnie folder Scripts (Skrypty ), aby go otworzyć.

2. Kliknij prawym przyciskiem myszy wewnątrz folderu Scripts (Skrypty ), kliknij pozycję Create C# Script (Utwórz > skrypt języka C#). Nadaj skryptowi nazwę LuisManager.

3. Kliknij dwukrotnie skrypt, aby go otworzyć za pomocą programu Visual Studio.

4. Dodaj następujące przestrzenie nazw na początku pliku:

       using System;
       using System.Collections;
       using System.Collections.Generic;
       using System.IO;
       using UnityEngine;
       using UnityEngine.Networking;
   

5. Zaczniesz od utworzenia trzech klas w klasie LuisManager (w tym samym pliku skryptu powyżej metody Start(), która będzie reprezentować deserializowaną odpowiedź JSON z platformy 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. Następnie dodaj następujące zmienne w klasie 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. Pamiętaj, aby umieścić punkt końcowy usługi LUIS w tej chwili (który będzie miał miejsce w portalu usługi LUIS).

8. Należy teraz dodać kod metody Awake(). Ta metoda zostanie wywołana, gdy klasa inicjuje:

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

9. Teraz potrzebne są metody używane przez tę aplikację do wysyłania dyktowania odebranego z klasy MicrophoneManager do usługi LUIS, a następnie odbierania i deserializacji odpowiedzi.

10. Po określeniu wartości intencji i skojarzonych jednostek zostaną one przekazane do wystąpienia klasy Zachowania w celu wyzwolenia zamierzonej akcji.

        /// <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. Utwórz nową metodę o nazwie AnalysisResponseElements(), która odczytuje wynikową metodę AnalysisdQuery i określ jednostki. Po określeniu tych jednostek zostaną one przekazane do wystąpienia klasy Behaviors do użycia w akcjach.

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

    Ważne

    Usuń metody Start() i Update(), ponieważ ta klasa nie będzie ich używać.

12. Pamiętaj, aby zapisać zmiany w programie Visual Studio przed powrotem do aparatu Unity.

Uwaga

W tym momencie zauważysz kilka błędów wyświetlanych w panelu konsoli edytora aparatu Unity. Jest to spowodowane tym, że kod odwołuje się do klasy Zachowania , którą utworzysz w następnym rozdziale.

Rozdział 7 — Tworzenie klasy Zachowania

Klasa Behaviors wyzwoli akcje przy użyciu jednostek dostarczonych przez klasę LuisManager .

Aby utworzyć tę klasę:

1. Kliknij dwukrotnie folder Scripts (Skrypty ), aby go otworzyć.

2. Kliknij prawym przyciskiem myszy wewnątrz folderu Scripts (Skrypty ), kliknij pozycję Create C# Script (Utwórz > skrypt języka C#). Nadaj skryptowi nazwę Zachowanie.

3. Kliknij dwukrotnie skrypt, aby go otworzyć za pomocą programu Visual Studio.

4. Następnie dodaj następujące zmienne w klasie 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. Dodaj kod metody Awake(). Ta metoda zostanie wywołana, gdy klasa inicjuje:

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

6. Następujące metody są wywoływane przez klasę LuisManager (utworzoną wcześniej), aby określić, który obiekt jest obiektem docelowym zapytania, a następnie wyzwolić odpowiednią akcję.

       /// <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. Dodaj metodę FindTarget(), aby określić, która z obiektów GameObjects jest elementem docelowym bieżącej intencji. Ta metoda domyślnie obiekt docelowy obiektu GameObject jest "patrzyny", jeśli w jednostkach nie zdefiniowano żadnego jawnego obiektu docelowego.

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

   Ważne

   Usuń metody Start() i Update(), ponieważ ta klasa nie będzie ich używać.

8. Pamiętaj, aby zapisać zmiany w programie Visual Studio przed powrotem do aparatu Unity.

Rozdział 8 — tworzenie klasy spojrzenia

Ostatnia klasa, którą musisz ukończyć, to klasa Gaze . Ta klasa aktualizuje odwołanie do obiektu GameObject obecnie w fokusie wizualizacji użytkownika.

Aby utworzyć tę klasę:

1. Kliknij dwukrotnie folder Scripts (Skrypty ), aby go otworzyć.

2. Kliknij prawym przyciskiem myszy wewnątrz folderu Scripts (Skrypty ), kliknij pozycję Create C# Script (Utwórz > skrypt języka C#). Nadaj nazwę gazecie skryptu.

3. Kliknij dwukrotnie skrypt, aby go otworzyć za pomocą programu Visual Studio.

4. Wstaw następujący kod dla tej klasy:

       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. Pamiętaj, aby zapisać zmiany w programie Visual Studio przed powrotem do aparatu Unity.

Rozdział 9 — kończenie konfiguracji sceny

1. Aby ukończyć instalację sceny, przeciągnij każdy skrypt utworzony z folderu Scripts do obiektu Main Camera w panelu hierarchii.

2. Wybierz kamerę główną i przyjrzyj się panelowi inspektora. Powinien być widoczny każdy dołączony skrypt i zauważysz, że na każdym skrypcie są jeszcze ustawione parametry.

   

3. Aby poprawnie ustawić te parametry, wykonaj następujące instrukcje:

   1. MikrofonManager:

      • Z panelu hierarchii przeciągnij obiekt Text Dictation do pola wartości parametru Dictation Text .

   2. Zachowania z panelu hierarchii:

      • Przeciągnij obiekt Sphere do pola docelowego odwołania do usługi Sphere .
      • Przeciągnij cylindra do pola docelowego odniesienia cylindra .
      • Przeciągnij moduł do pola docelowego odwołania do modułu .

   3. Spojrzenie:

      • Ustaw maksymalną odległość spojrzenia na 300 (jeśli jeszcze nie jest).

4. Wynik powinien wyglądać podobnie do poniższego obrazu:

   

Rozdział 10 — testowanie w edytorze aparatu Unity

Przetestuj, czy konfiguracja sceny jest prawidłowo zaimplementowana.

Upewnij się, że:

• Wszystkie skrypty są dołączone do obiektu Main Camera .
• Wszystkie pola w głównym panelu inspektora kamery są prawidłowo przypisywane.

1. Naciśnij przycisk Odtwórz w edytorze aparatu Unity. Aplikacja powinna być uruchomiona w dołączonym immersywnym zestawie słuchawkowym.

2. Spróbuj wykonać kilka wypowiedzi, takich jak:

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

   Uwaga

   Jeśli w konsoli aparatu Unity zostanie wyświetlony błąd dotyczący zmiany domyślnego urządzenia audio, scena może nie działać zgodnie z oczekiwaniami. Wynika to ze sposobu, w jaki portal rzeczywistości mieszanej zajmuje się wbudowanymi mikrofonami dla zestawów słuchawkowych, które je mają. Jeśli ten błąd zostanie wyświetlony, po prostu zatrzymaj scenę i uruchom ją ponownie, a wszystko powinno działać zgodnie z oczekiwaniami.

Rozdział 11 — kompilowanie i ładowanie bezpośrednie rozwiązania platformy UWP

Po upewnieniu się, że aplikacja działa w Edytorze aparatu Unity, możesz przystąpić do kompilowania i wdrażania.

Aby skompilować:

1. Zapisz bieżącą scenę, klikając pozycję Zapisz plik>.

2. Przejdź do pozycji Ustawienia kompilacji pliku>.

3. Zaznacz pole o nazwie Unity C# Projects (przydatne do wyświetlania i debugowania kodu po utworzeniu projektu platformy UWP.

4. Kliknij pozycję Dodaj otwarte sceny, a następnie kliknij pozycję Kompiluj.

   

5. Zostanie wyświetlony monit o wybranie folderu, w którym chcesz skompilować rozwiązanie.

6. Utwórz folder BUILDS i w tym folderze utwórz inny folder z wybraną odpowiednią nazwą.

7. Kliknij pozycję Wybierz folder , aby rozpocząć kompilację w tej lokalizacji.

   

8. Po zakończeniu kompilowania aparatu Unity (może to zająć trochę czasu), powinno zostać otwarte okno Eksplorator plików w lokalizacji kompilacji.

Aby wdrożyć na komputerze lokalnym:

1. W programie Visual Studio otwórz plik rozwiązania utworzony w poprzednim rozdziale.

2. W obszarze Platforma rozwiązania wybierz pozycję x86, Komputer lokalny.

3. W obszarze Konfiguracja rozwiązania wybierz pozycję Debuguj.

   W przypadku Microsoft HoloLens można łatwiej ustawić tę opcję na Maszynę zdalną, aby nie być nastawiona na komputer. Należy jednak również wykonać następujące czynności:

   • Poznaj adres IP urządzenia HoloLens, który można znaleźć w obszarze Ustawienia > sieci & Opcje zaawansowane Wi-Fi > Internet>; adres IPv4 jest adresem, którego należy użyć.
   • Upewnij się, że tryb dewelopera jest włączony; znaleziono w temacie Ustawienia > Aktualizuj & Zabezpieczenia > dla deweloperów.

   

4. Przejdź do menu Kompilacja i kliknij pozycję Wdróż rozwiązanie , aby załadować aplikację bezpośrednio na maszynę.

5. Aplikacja powinna być teraz wyświetlana na liście zainstalowanych aplikacji, gotowych do uruchomienia.

6. Po uruchomieniu aplikacja wyświetli monit o autoryzowanie dostępu do mikrofonu. Użyj kontrolerów ruchu lub danych wejściowych głosu lub klawiatury , aby nacisnąć przycisk TAK .

Rozdział 12 — Ulepszanie usługi LUIS

Ważne

Ten rozdział jest niezwykle ważny i może wymagać iteracji kilka razy, ponieważ pomoże to poprawić dokładność usługi LUIS: upewnij się, że wykonasz tę funkcję.

Aby poprawić poziom zrozumienia dostarczony przez usługę LUIS, musisz przechwycić nowe wypowiedzi i użyć ich do ponownego trenowania aplikacji usługi LUIS.

Na przykład możesz wytrenować usługę LUIS, aby zrozumieć "Zwiększenie" i "Upsize", ale nie chcesz, aby aplikacja zrozumiała również słowa takie jak "Powiększanie"?

Gdy aplikacja została użyta kilka razy, wszystko, co powiedziałeś, zostanie zebrane przez usługę LUIS i będzie dostępne w portalu usługi LUIS.

1. Przejdź do aplikacji portalu, postępując zgodnie z tym linkiem i zaloguj się.

2. Po zalogowaniu się przy użyciu poświadczeń ms kliknij swoją nazwę aplikacji.

3. Kliknij przycisk Przejrzyj wypowiedzi punktu końcowego po lewej stronie.

   

4. Zostanie wyświetlona lista wypowiedzi wysłanych do usługi LUIS przez aplikację rzeczywistości mieszanej.

   

Zauważysz niektóre wyróżnione jednostki.

Po umieszczeniu wskaźnika myszy na każdym wyróżnionym słowie możesz przejrzeć każdą wypowiedź i określić, która jednostka została prawidłowo rozpoznana, które jednostki są nieprawidłowe i które jednostki zostały pominięte.

W powyższym przykładzie stwierdzono, że słowo "włócznia" zostało wyróżnione jako element docelowy, dlatego konieczne jest skorygowanie błędu, co jest wykonywane przez umieszczenie kursora na słowie za pomocą myszy i kliknięcie przycisku Usuń etykietę.

5. Jeśli znajdziesz wypowiedzi, które są całkowicie nieprawidłowe, możesz je usunąć przy użyciu przycisku Usuń po prawej stronie ekranu.

   

6. Jeśli uważasz, że usługa LUIS poprawnie zinterpretowała wypowiedź, możesz zweryfikować jego zrozumienie za pomocą przycisku Dodaj do wyrównanej intencji .

   

7. Po posortowania wszystkich wyświetlanych wypowiedzi spróbuj ponownie załadować stronę, aby sprawdzić, czy więcej jest dostępnych.

8. Bardzo ważne jest, aby powtórzyć ten proces tak wiele razy, jak to możliwe, aby poprawić zrozumienie aplikacji.

Baw się dobrze!

Zakończona aplikacja zintegrowana z usługą LUIS

Gratulacje, utworzono aplikację rzeczywistości mieszanej, która korzysta z usługi Azure Language Understanding Intelligence Service, aby zrozumieć, co mówi użytkownik i jak działa na temat tych informacji.

Ćwiczenia dodatkowe

Ćwiczenie 1

Korzystając z tej aplikacji, możesz zauważyć, że jeśli patrzysz na obiekt Floor i poprosisz o zmianę koloru, zrobi to. Czy możesz dowiedzieć się, jak zatrzymać zmianę koloru podłogi w aplikacji?

Ćwiczenie 2

Spróbuj rozszerzyć możliwości usługi LUIS i aplikacji, dodając dodatkowe funkcje dla obiektów w scenie; na przykład utwórz nowe obiekty w punkcie trafienia gazecie, w zależności od tego, co mówi użytkownik, a następnie być w stanie używać tych obiektów obok bieżących obiektów sceny z istniejącymi poleceniami.