HoloLens (1. generacji) i Azure 303: Rozpoznawanie języka naturalnego (LUIS)

Uwaga

Samouczki akademii rzeczywistości mieszanej zostały zaprojektowane z myślą o urządzeniach HoloLens (1. generacji) i zestawach słuchawkowych immersyjnych rzeczywistości mieszanej. W związku z tym uważamy, że ważne jest pozostawienie tych samouczków na miejscu dla deweloperów, którzy nadal szukają wskazówek dotyczących opracowywania tych urządzeń. Te samouczki nie zostaną zaktualizowane przy użyciu najnowszych zestawów narzędzi ani interakcji używanych dla urządzenia 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ć urządzenia HoloLens 2. To powiadomienie zostanie zaktualizowane za pomocą linku do tych samouczków po ich opublikowaniu.

W tym kursie dowiesz się, jak zintegrować usługę Language Understanding z aplikacją rzeczywistości mieszanej przy użyciu usług Azure Cognitive Services z interfejsem API usługi 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ć osoba, we własnych słowach. Jest to osiągane za pomocą uczenia maszynowego, które rozumie i uczy się informacji wejściowych, a następnie może odpowiedzieć za pomocą szczegółowych, odpowiednich 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 immersyjnego zestawu słuchawkowego.
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 ustalenia 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 zostanie objęte.

W aplikacji należy do Ciebie, jak zintegrować wyniki z projektem. Ten kurs został zaprojektowany, aby nauczyć cię, jak zintegrować usługę platformy Azure z projektem aparatu Unity. Twoim zadaniem jest wykorzystanie wiedzy uzyskanych 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: Informacje o języku naturalnym (LUIS)	✔️	✔️

Uwaga

Chociaż ten kurs koncentruje się głównie na zestawach nagłownych immersywnych windows Mixed Reality (VR), możesz również zastosować to, czego nauczysz się w tym kursie do urządzenia Microsoft HoloLens. Zgodnie 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ć 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 bezpłatnie korzystać z najnowszego oprogramowania, jak wymieniono w artykule dotyczącym instalacji narzędzi , choć nie należy zakładać, że informacje zawarte w tym kursie doskonale pasują do tego, co znajdziesz w nowszym oprogramowaniu niż wymienione poniżej.

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

• Komputer deweloperzy zgodny z windows Mixed Reality na potrzeby programowania immersyjnego zestawu słuchawkowego (VR)
• Windows 10 Fall Creators Update (lub nowszy) z włączonym trybem dewelopera
• Najnowszy zestaw SDK systemu 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 dla konfiguracji 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 funkcji Dyktowania, przejdź do pozycji Ustawienia systemu Windows > > Prywatność mowy, Pisma odręczne i wpisywanie i naciśnij przycisk Włącz usługi mowy i wpisywanie sugestii.

3. Kod w tym samouczku umożliwi rejestrowanie z urządzenia mikrofonu domyślnego 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 "Kiedy nosim zestaw słuchawkowy, przełącznik do mikrofonu nagłownego" jest włączona w ustawieniach portalu rzeczywistości mieszanej.

   

Rozdział 1 — Konfigurowanie witryny Azure Portal

Aby korzystać z usługi Language Understanding na platformie Azure, należy skonfigurować wystąpienie usługi, które ma zostać udostępnione aplikacji.

1. Zaloguj się do Portalu Azure.

   Uwaga

   Jeśli nie masz jeszcze konta platformy Azure, musisz je utworzyć. Jeśli obserwujesz ten samouczek w sytuacji w klasie 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 ciąg 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 odpowiednią warstwę cenową, jeśli jest to pierwszy raz podczas tworzenia usługi LUIS, warstwa bezpłatna (o nazwie F0) powinna być dostępna dla Ciebie. 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ę zachowanie wszystkich usług platformy Azure skojarzonych z jednym 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ę dla grupy zasobów (jeśli tworzysz nową grupę zasobów). Lokalizacja najlepiej znajdować się w regionie, w którym aplikacja będzie uruchamiana. 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 pozycję 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 klucze hiperłącza, znajdujące się w menu nawigacji usług, oznaczone ikoną klucza). Spowoduje to wyświetlenie kluczy usługi.

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

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

Rozdział 2 — Portal usługi 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 w tworzeniu usługi LUIS: należy również ponownie wytrenować usługę, kilka razy, aby uczynić ją bardziej dokładną. Ponowne trenowanie usługi zostało omówione w ostatnim rozdziale tego kursu, więc upewnij się, że ją ukończysz.

1. Po dotarciu do portalu Usługi Language Understanding może być konieczne zalogowanie się, jeśli jeszcze tego nie zrobiono, przy użyciu tych samych poświadczeń co witryna 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 ma 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 to składnik zapytania, który opisuje 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:

    • upsize
    • obniżanie rozmiaru
    • cel

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, więc 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 Enter:

The color of the cylinder must be red

Zauważysz, że nowa wypowiedź pojawi się 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 wyrazy 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 obiektu docelowego jako jednostki docelowej .

15. Aby to zrobić, spróbuj kliknąć cylinder słowa w pierwszej wypowiedzi i wybrać element docelowy.

    

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

    

17. Oznacz etykietę następnego wiersza, gdzie moduł powinien być elementem docelowym, a powinien być kolorem. Zwróć również uwagę na użycie wyrazów "this", "it" i "this object", które udostępniamy, więc mają dostępne również nieokreśliwne typy docelowe.

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

    Napiwek

    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łącznika Widok tokenów, aby przełączać się między jednostkami / widokiem tokenów!

19. Wyniki powinny być widoczne na poniższych obrazach, 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 wskaźnik zaokrąglony na nim stanie się 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 być podobny do tego na poniższej ilustracji:

    

24. Gdy obie intencje, ChangeObjectColor i ChangeObjectSize, zostały utworzone i wytrenowane, kliknij przycisk PUBLIKUJ w górnej części strony.

    

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

    1. Ustaw listę rozwijaną Publikuj jako produkcyjną.

    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 poniżej Starter_Key element, 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 wcześniej w witrynie Azure Portal.

    Ważne

    Poniżej punktu końcowego 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 Ciebie (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 urządzenia 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. Dla wersji programu Visual Studio jest ustawiona wartość Najnowsza zainstalowana

   5. Kompilowanie i uruchamianie jest ustawione na komputer lokalny

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

      1. W tym celu wybierz pozycję Dodaj otwarte sceny. Zostanie wyświetlone okno zapisywania.

         

      2. Utwórz nowy folder dla tego i dowolnej przyszłości 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 ustawienia publikowania) zaznacz pole Virtual Reality Supported (Obsługiwane w rzeczywistości wirtualnej), upewnij się, że dodano zestaw WINDOWS Mixed Reality SDK .

      

8. Po powrocie do ustawień kompilacji Projekty języka C# środowiska Unity 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 Konfiguracji aparatu Unity 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 powyższą procedurę, aby dodać następujące obiekty:

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

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

   

5. Kliknij lewym przyciskiem myszy aparat główny , aby go zaznaczyć, spójrz na Panel inspektora, zobaczysz obiekt Aparat ze wszystkimi jego składnikami.

6. Kliknij przycisk Dodaj składnik znajdujący się w dolnej części 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łć 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. Wartość obrotu to 0, 0, 0.

   Uwaga

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

   • Wyczyść flagi: kolor jednolity.
   • Tło ", Alfa 0" — kolor szesnastkowy: #00000000.

9. Kliknij lewym przyciskiem myszy płaszczyznę, aby ją wybrać. W panelu Inspector (Panel inspektora) ustaw składnik Transform z następującymi wartościami:

   Oś X	Oś Y	Osi
   0	-1	0

10. Kliknij lewym przyciskiem myszy pozycję Sphere , aby ją wybrać. W panelu Inspector (Panel inspektora) ustaw składnik Transform z następującymi wartościami:

    Oś X	Oś Y	Osi
    2	1	2

11. Kliknij prawym przyciskiem myszy cylinder , aby go wybrać. W panelu Inspector (Panel 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 Inspector (Panel 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 Inspector (Panel 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 Siatki tekstu na Tekst Dyktowania.

    

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

    

17. Ostateczna scena powinna wyglądać podobnie do poniższego obrazu:

    

Rozdział 5 — Tworzenie klasy MicrophoneManager

Pierwszy skrypt, który chcesz utworzyć, to klasa MicrophoneManager . Po wykonaniu tej czynności utworzysz klasę LuisManager, zachowanie i na koniec 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 nagłownego lub maszyny (w zależności od tego, która z nich 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 w panelu projektu, Utwórz > folder. Wywołaj folder Scripts.

   

2. Po utworzeniu folderu Skrypty 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 menedżera mikrofonów, 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 wewnątrz klasy 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. Teraz należy 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, a następnie przekazania 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 program obsługi Dyktowania, który będzie wywoływany 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. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

   Uwaga

   W tym momencie w Panelu konsoli edytora aparatu Unity zostanie wyświetlony błąd. Jest to spowodowane tym, że kod odwołuje się do klasy LuisManager , która zostanie utworzona 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 zdeserializuje odpowiedź JSON i wywoła odpowiednie metody klasy Behaviors w celu wyzwolenia akcji.

Aby utworzyć tę klasę:

1. Kliknij dwukrotnie folder Skrypty, aby go otworzyć.

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

3. Kliknij dwukrotnie skrypt, aby otworzyć go 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 wewnątrz klasy 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. Upewnij się, że punkt końcowy usługi LUIS znajduje się teraz (który będzie miał miejsce w portalu usługi LUIS).

8. Teraz należy 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 Intencja i skojarzone jednostki są przekazywane 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. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

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 Behaviors , którą utworzysz w następnym rozdziale.

Rozdział 7 — Tworzenie klasy Zachowania

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

Aby utworzyć tę klasę:

1. Kliknij dwukrotnie folder Skrypty, aby go otworzyć.

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

3. Kliknij dwukrotnie skrypt, aby otworzyć go 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 celem bieżącej intencji. Ta metoda domyślnie obiekt docelowy obiektu GameObject jest "patrzyny", jeśli w jednostkach nie zdefiniowano 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. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

Rozdział 8 — Tworzenie klasy Spojrzenia

Ostatnią klasą, którą należy ukończyć, jest klasa Gaze . Ta klasa aktualizuje odwołanie do obiektu GameObject obecnie w wizualizacji użytkownika.

Aby utworzyć tę klasę:

1. Kliknij dwukrotnie folder Skrypty, aby go otworzyć.

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

3. Kliknij dwukrotnie skrypt, aby otworzyć go 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. Przed powrotem do aparatu Unity pamiętaj o zapisaniu zmian w programie Visual Studio.

Rozdział 9 — kończenie konfiguracji sceny

1. Aby ukończyć konfigurację 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. Zauważysz, że istnieją parametry dla każdego skryptu, które nie zostały jeszcze ustawione.

   

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

   1. MikrofonManager:

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

   2. Zachowania z panelu hierarchii:

      • Przeciągnij obiekt Sphere do pola docelowego odwołania 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ść wzroku 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 panelu Główny inspektor 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. Wypróbuj 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 widzisz ten błąd, 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 środowiska 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, który został utworzony w poprzednim rozdziale.

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

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

   W przypadku urządzenia Microsoft HoloLens można łatwiej ustawić tę opcję na maszynę zdalną, aby nie być naciągniętym 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 > Sieć i Internet > Wi-Fi > Advanced Options. Adres IPv4 jest adresem, którego należy użyć.
   • Upewnij się, że tryb dewelopera jest włączony; znajduje się w obszarze Ustawienia > Aktualizacja i 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 wejścia głosowego lub klawiatury, aby nacisnąć przycisk TAK.

Rozdział 12 — Ulepszanie usługi LUIS

Ważne

Ten rozdział jest niezwykle ważny i może być konieczne wykonanie itelekcji kilka razy, ponieważ pomoże to poprawić dokładność usługi LUIS: upewnij się, że to zrobisz.

Aby poprawić poziom zrozumienia zapewniany przez usługę LUIS, należy 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 mogła również rozumieć słowa takie jak "Powiększ"?

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, które zostały wysłane do usługi LUIS przez aplikację rzeczywistości mieszanej.

   

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

Umieszczając kursor 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, więc 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 błędne, możesz je usunąć przy użyciu przycisku Usuń po prawej stronie ekranu.

   

6. Lub 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 są dostępne więcej.

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 zintegrowana aplikacja usługi 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 wykonywać na tych informacjach.

Ćwiczenia dodatkowe

Ćwiczenie 1

Podczas korzystania z tej aplikacji można 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 będzie w stanie używać tych obiektów obok bieżących obiektów sceny z istniejącymi poleceniami.