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


Uwaga

Samouczki Mixed Reality Academy zostały zaprojektowane z myślą o 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 przy użyciu najnowszych zestawów narzędzi ani interakcji używanych do 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ć dla 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.

Lab outcome

Language Understanding (LUIS) to usługa 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, we własnych 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 wykonywać 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 został zaprojektowany, aby nauczyć Cię, jak zintegrować usługę platformy Azure z Project 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. Po zakończeniu kursu zobaczysz notatki dotyczące wszelkich zmian, które mogą być konieczne do obsługi HoloLens. Podczas korzystania z 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 , chociaż 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:

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 Windows Ustawienia > mowy prywatności>, & wpisywania odręcznego i naciskania na przycisk Włącz usługi mowy i wpisywanie sugestii.

  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.

    Setting up immersive headset

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.

    Create LUIS resource

    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.

    LUIS service creation - legal notice

  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.

      Create LUIS service - user input

  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.

    New Azure notification image

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

    Successful resource creation notification

  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.

    Accessing LUIS Keys

  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.

    LUIS login page

  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 .

    Create LUIS app page

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

    LUIS - my apps image

  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.

    LUIS - create a new app

  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.

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

    Create new entity

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

    Create simple entity - color

  3. 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:

Result of entity creation

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

Ostrzeżenie

Nie usuwaj intencji None .

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

    Create new intents

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

LUIS - intents page

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.

  1. 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ą .

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

    Identify Utterance Targets

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

    Identify Utterance Entities

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

  4. 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!

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

    Tokens & Entities Views

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

    Train LUIS

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

  8. 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
    
  9. Wynik powinien przypominać ten na poniższej ilustracji:

    Setup the ChangeObjectSize Tokens/ Entities

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

    Publish LUIS service

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

      Publish Settings

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

    Start new Unity project.

  2. Teraz musisz podać nazwę Project 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.

    Provide details for new Unity project.

  3. Po otwarciu aparatu Unity warto sprawdzić, czy domyślny edytor skryptów jest ustawiony na 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 .

    Update script editor preference.

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

    Build Settings window, switch platform to UWP.

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

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

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

    2. Typ kompilacji jest ustawiony na D3D

    3. Zestaw SDK jest ustawiony na najnowszą zainstalowaną

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

    5. Kompilowanie i uruchamianie jest ustawione na maszynę lokalną

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

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

        Click add open scenes button

      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.

        Create new scripts folder

      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.

        Give new scene a name.

    7. Pozostałe ustawienia w obszarze Build Ustawienia (Kompilacja Ustawienia) powinny być pozostawione jako domyślne.

  6. W oknie Ustawienia kompilacji kliknij przycisk Odtwarzacz Ustawienia. Spowoduje to otwarcie powiązanego panelu w przestrzeni, w której znajduje się inspektor.

    Open player settings.

  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. Tworzenie skryptów zaplecza powinno mieć wartość .NET

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

        Update other settings.

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

      1. InternetClient

      2. Mikrofon

        Updating publishing settings.

    3. W dalszej części panelu, w Ustawienia XR (znaleziono poniżej publikowania Ustawienia), zaznacz pole wyboru Obsługa rzeczywistości wirtualnej, upewnij się, że zestaw SDK Windows Mixed Reality został dodany.

      Update the X R Settings.

  8. Po powrocie do pozycji Build UstawieniaUnity Projekty języka C# nie są już wyszarzone; zaznacz pole wyboru obok tego pola wyboru.

  9. Zamknij okno Build Settings (Ustawienia kompilacji).

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

Rozdział 4 — Tworzenie sceny

Ważne

Jeśli chcesz pominąć składnik konfiguracji aparatu Unity w tym kursie 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ę.

    Create a plane.

  2. Należy pamiętać, że po ponownym kliknięciu prawym przyciskiem myszy w hierarchii w celu utworzenia większej liczby obiektów, jeśli ostatni obiekt jest zaznaczony, 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. Kula
    2. Cylinder
    3. Sześcian
    4. Tekst 3D
  4. Wynikowa hierarchia sceny powinna być podobna do tej na poniższej ilustracji:

    Scene Hierarchy setup.

  5. Kliknij lewym przyciskiem myszy kamerę główną , aby ją zaznaczyć, przyjrzyj się Panelowi inspektora zobaczysz obiekt Camera ze wszystkimi jego składnikami.

  6. Kliknij przycisk Dodaj składnik znajdujący się w dolnej części panelu Inspektor.

    Add Audio Source

  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. Obrót jest ustawiony na 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ę w aparacie głównym:

    • Wyczyść flagi: Pełny kolor.
    • Tle "Czarny, Alfa 0" — kolor szesnastkowy: #00000000.
  9. Kliknij lewym przyciskiem myszy płaszczyznę , aby ją wybrać. W panelu Inspector (Inspektor panel ) 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ą zaznaczyć. W panelu Inspector (Inspektor panel ) ustaw składnik Transform z następującymi wartościami:

    Oś X Oś Y Osi
    2 1 2
  11. Kliknij lewym przyciskiem myszy cylinder , aby go wybrać. W panelu Inspector (Inspektor panel ) 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 (Inspektor panel ) 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
  1. Kliknij lewym przyciskiem myszy obiekt Nowy tekst , aby go zaznaczyć. W panelu Inspector (Inspektor panel ) 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
  1. Zmień rozmiar czcionki w składniku Mesh tekstu na 50.

  2. Zmień nazwę obiektu Text Mesh na Tekst Dyktowania.

    Create 3D Text object

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

    text mesh in scene view

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

    The scene view.

Rozdział 5 — Tworzenie klasy MicrophoneManager

Pierwszym skryptem, który chcesz utworzyć, jest klasa MicrophoneManager . W związku z tym utworzysz klasę LuisManager, behaviors i ostatnio klasę Gaze (możesz utworzyć wszystkie te elementy teraz, chociaż będzie ona pokryta 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 panel Project, Utwórz > folder. Wywołaj folder Scripts.

    Create Scripts folder.

  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ę MicrophoneManager, aby otworzyć go za pomocą 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 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 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. Pamiętaj, aby zapisać zmiany w Visual Studio przed powrotem do aparatu Unity.

    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 , aby wyzwolić akcję.

Aby utworzyć tę klasę:

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

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

  3. Kliknij dwukrotnie skrypt, aby otworzyć go za pomocą 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. Rozpoczniesz od utworzenia trzech klas wewnątrz klasy 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. Pamiętaj, aby teraz umieścić punkt końcowy usługi LUIS (który będzie dostępny w portalu usługi LUIS).

  8. Należy teraz dodać kod dla 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 potrzebujesz metod używanych przez tę aplikację do wysyłania dyktowania otrzymanego 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ą one przekazywane do wystąpienia klasy Behaviors 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 wynikowe zapytanie 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 Visual Studio przed powrotem do aparatu Unity.

Uwaga

W tym momencie w panelu konsoli edytora aparatu Unity zostanie wyświetlonych kilka błędów. 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 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 ), a następnie kliknij polecenie Create C# Script (Utwórz > skrypt języka C#). Nadaj skryptowi nazwę Zachowanie.

  3. Kliknij dwukrotnie skrypt, aby otworzyć go za pomocą 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 "zaglądany", 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. Pamiętaj, aby zapisać zmiany w Visual Studio przed powrotem do aparatu Unity.

Rozdział 8 — Tworzenie klasy spojrzenia

Ostatnią klasą, którą należy ukończyć, jest klasa Gaze . Ta klasa aktualizuje odwołanie do obiektu GameObject aktualnie 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 ), a następnie kliknij polecenie Create C# Script (Utwórz > skrypt języka C#). Nadaj skryptowi nazwę Gaze.

  3. Kliknij dwukrotnie skrypt, aby otworzyć go za pomocą 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 Visual Studio przed powrotem do aparatu Unity.

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. Powinno być możliwe wyświetlenie każdego dołączonego skryptu. Zauważysz, że w każdym skrypcie istnieją parametry, które nie zostały jeszcze ustawione.

    Setting the Camera Reference Targets.

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

    1. MikrofonManager:

      • Z panelu hierarchii przeciągnij obiekt Tekst Dyktowania do pola wartość parametru Dictation Text .
    2. Zachowania z panelu hierarchii:

      • Przeciągnij obiekt Sphere do pola docelowego odwołania sphere .
      • Przeciągnij cylinder do pola docelowego odniesienia cylindra .
      • Przeciągnij moduł do pola docelowego odwołania do modułu .
    3. Spojrzenie:

      • Ustaw wartość 300dla opcji Maksymalna odległość spojrzenia (jeśli jeszcze nie jest).
  4. Wynik powinien wyglądać podobnie do poniższego obrazu:

    Showing the Camera Reference Targets, now set.

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 przypisane.
  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. Jest to spowodowane sposobem, 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 Kompilacja pliku > Ustawienia.

  3. Zaznacz pole o nazwie Projekty języka C# aparatu Unity (przydatne do wyświetlania i debugowania kodu po utworzeniu projektu platformy UWP.

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

    Build Settings window

  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.

    Create Builds FolderSelect Builds Folder

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

Aby wdrożyć na komputerze lokalnym:

  1. W Visual Studio otwórz plik rozwiązania 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 Microsoft HoloLens można łatwiej ustawić tę opcję na Maszynę zdalną, aby nie być na tym komputerze. Należy jednak również wykonać następujące czynności:

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

    Deploy App

  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 iteratedu 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ć wartości "Zwiększ" i "Zwiększ rozmiar", ale nie chcesz, aby aplikacja mogła również rozumieć słowa takie jak "Powiększ"?

Gdy aplikacja została użyta kilka razy, wszystkie elementy, które zostały powiedziane, zostaną zebrane przez usługę LUIS i będą 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.

    Review Utterances

  4. Zostanie wyświetlona lista wypowiedzi, które zostały wysłane do usługi LUIS przez aplikację rzeczywistości mieszanej.

    List of Utterances

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

Umieszczając wskaźnik 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 można zrobić, umieszczając wskaźnik myszy na słowie i klikając polecenie Usuń etykietę.

Check utterancesRemove Label Image

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

    Delete wrong utterances

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

    Add to aligned intent

  3. Po posortowania wszystkich wyświetlanych wypowiedzi spróbuj ponownie załadować stronę, aby sprawdzić, czy są dostępne więcej.

  4. Bardzo ważne jest, aby powtarzać ten proces jak najwięcej razy, 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 tych informacjach.

Lab outcome

Ćwiczenia dodatkowe

Ćwiczenie 1

Korzystając z tej aplikacji, można zauważyć, że jeśli patrzysz na obiekt Floor i poprosisz o zmianę jego 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.