HoloLens (1. generacja) i Azure 303: rozumienie języka naturalnego (LUIS)


Uwaga

Samouczki Mixed Reality Academy zostały zaprojektowane z myślą o HoloLens (1. generacji) i Mixed Reality immersywnych. W związku z tym uważamy, że ważne jest pozostawienie tych samouczków dla deweloperów, którzy nadal szukają wskazówek dotyczących opracowywania aplikacji dla tych urządzeń. Te samouczki nie zostaną zaktualizowane o najnowsze zestawy narzędzi lub interakcje używane w 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 zademonstrują sposób tworzenia aplikacji dla HoloLens 2. Ta informacja zostanie zaktualizowana przy użyciu linku do tych samouczków, gdy zostaną opublikowane.


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

Wynik laboratorium

Language Understanding (LUIS) to usługa Microsoft Azure, która umożliwia aplikacjom wprowadzanie znaczenia danych wejściowych przez użytkownika, na przykład poprzez wyodrębnianie tego, czego może chcieć osoba, własnymi słowami. Jest to osiągane przez uczenie maszynowe, 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ć immersywną aplikację nagłowną 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 nagłownego.
  2. Wyślij przechwyconą dyktację do usługi Azure Language Understanding Intelligent Service (LUIS).
  3. Usługa LUIS musi wyodrębnić znaczenie z informacji o wysyłaniu, które zostaną przeanalizowane, i spróbuje określić intencję żądania użytkownika.

Opracowywanie będzie obejmować tworzenie aplikacji, w której użytkownik będzie mógł za pomocą głosu i/lub spojrzenia zmienić rozmiar i kolor obiektów w scenie. Korzystanie z kontrolerów ruchu nie zostanie uwzględnione.

W aplikacji to Ty musisz dowiedzieć się, jak zintegrować wyniki z projektem. Ten kurs ma na celu nauczenie Cię, jak zintegrować usługę platformy Azure z platformą Unity Project. Twoim zadaniem jest wykorzystanie wiedzy zdobytej podczas tego kursu w celu ulepszania aplikacji rzeczywistości mieszanej.

Przygotuj się do kilkudniowego szkolenia usługi LUIS, co o czym omówmy w rozdziale 12. Im więcej razy usługa LUIS zostanie wytrenowana, wyniki będą lepsze.

Obsługa urządzeń

Kurs HoloLens Immersywne zestawy nagłow
MR i Azure 303: rozumienie języka naturalnego (LUIS) ✔️ ✔️

Uwaga

Chociaż ten kurs koncentruje się głównie Windows Mixed Reality na immersywnych zestawach nagłownych (VR), możesz również zastosować to, czego się nauczysz w tym kursie, Microsoft HoloLens. Podczas śledzenia kursu zobaczysz notatki dotyczące wszelkich zmian, które mogą być konieczne do obsługi HoloLens. Podczas korzystania 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 z aparatu Unity i języka C#. Należy również pamiętać, że wymagania wstępne i instrukcje w tym dokumencie reprezentują to, co zostało przetestowane i zweryfikowane w momencie pisania (maj 2018 r.). Zgodnie z informacjami w artykule instalacja narzędzi możesz korzystać z najnowszego oprogramowania, chociaż nie należy zakładać, że informacje w tym kursie będą idealnie zgodne z informacjami w nowszej wersji oprogramowania niż wymienione poniżej.

Na ten kurs zalecamy użycie następującego sprzętu i oprogramowania:

Przed rozpoczęciem

  1. Aby uniknąć problemów podczas kompilowania tego projektu, zdecydowanie zaleca się utworzenie projektu wspomnianego 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łączenie funkcji dyktowania, przejdź do tematu Windows Ustawienia > Privacy > Speech, Inking & Typing (Włączanie usług mowy i wpisywanie sugestii) na stronie Inking & Typing (Włącz usługi mowy).

  3. Kod w tym samouczku umożliwia rejestrowanie z domyślnego urządzenia mikrofonu ustawionego na maszynie. Upewnij się, że domyślne urządzenie mikrofonu jest ustawione jako to, które ma być służące do przechwytywania głosu.

  4. Jeśli zestaw nagłowny ma wbudowany mikrofon, upewnij się, że opcja "Gdy najecham na zestaw nagłowny, przełącz na mikrofon" jest włączona w ustawieniach Portal rzeczywistości mieszanej nagłownego.

    Konfigurowanie immersywnego zestawu nagłownego

Rozdział 1 — Konfigurowanie witryny Azure Portal

Aby użyć 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 używasz tego samouczka w sytuacji na potrzeby zajęć lub laboratorium, poproś instruktora lub jednego z nauczycieli o pomoc przy konfigurowaniu nowego konta.

  2. Po zalogowaniu kliknij pozycję Nowy w lewym górnym rogu, wyszukaj hasło Language Understanding i naciśnij klawisz Enter.

    Tworzenie zasobu usługi LUIS

    Uwaga

    Wyraz Nowy mógł zostać zastąpiony słowem Utwórz zasób w nowszej witrynie Portal.

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

    Tworzenie usługi LUIS — informacje prawne

  4. Po kliknięciu przycisku Utwórz:

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

    2. Wybierz subskrypcję.

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

    4. Wybierz grupę zasobów lub utwórz nową. Grupa zasobów umożliwia monitorowanie, kontrolowanie dostępu, aprowizowanie i zarządzanie rozliczeniami dla kolekcji zasobów platformy Azure. Zaleca się, aby wszystkie usługi platformy Azure skojarzone z pojedynczym projektem (np. takimi jak te kursy) były w ramach wspólnej grupy zasobów.

      Jeśli chcesz dowiedzieć się więcej o grupach zasobów platformy Azure, zapoznaj się z artykułem grupy zasobów.

    5. Określ lokalizację grupy zasobów (jeśli tworzysz nową grupę zasobów). Najlepiej byłoby, gdyby ta lokalizacja znajdujeła się w regionie, w którym aplikacja byłaby 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 przycisk Utwórz.

      Tworzenie usługi LUIS — dane wejściowe użytkownika

  5. Po kliknięciu przycisku Utwórz musisz poczekać na utworzenie usługi. Może to potrwać minutę.

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

    Nowy obraz powiadomień platformy Azure

  7. Kliknij powiadomienie, aby eksplorować nowe wystąpienie usługi.

    Powiadomienie o pomyślnym utworzeniu zasobu

  8. Kliknij przycisk Przejdź do zasobu w powiadomieniu, aby eksplorować nowe wystąpienie usługi. Zostaniesz przekierowyny do nowego wystąpienia usługi LUIS.

    Uzyskiwanie dostępu do kluczy usługi LUIS

  9. W tym samouczku aplikacja będzie wymagać wywołań do usługi, co odbywa się za pośrednictwem klucza subskrypcji usługi.

  10. Na stronie Szybki start usługi interfejsu API usługi LUIS przejdź do pierwszego kroku, kliknij pozycję Grab your keys(Klucze) i kliknij pozycję Keys (Klucze), klikając niebieski hiperlink Keys (Klucze), który znajduje się w menu nawigacji usług, co jest oznaczone ikoną klucza. Spowoduje to ujawnienie kluczy usługi.

  11. Skopiuj jeden z wyświetlonych kluczy, ponieważ będzie on potrzebny w dalszej części projektu.

  12. Na stronie Usługa kliknij pozycję portal Language Understanding, aby przekierowywać do strony internetowej, za pomocą której utworzysz nową usługę, w aplikacji LUIS.

Rozdział 2 — Language Understanding Portal

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

Ważne

Pamiętaj, że skonfigurowanie jednostek, intencji i wypowiedzi w tym rozdziale jest tylko pierwszym krokiem podczas tworzenia usługi LUIS: konieczne będzie również kilkukrotnie ponowne szkolenie usługi, aby była bardziej dokładna. Ponowne trenowanie usługi jest uwzględnione w ostatnim rozdziale tego kursu, dlatego upewnij się, że ją ukończono.

  1. Po dotarciu do Language Understanding Portal może być konieczne zalogowanie się przy użyciu tych samych poświadczeń co konto Azure Portal.

    Strona logowania usługi LUIS

  2. Jeśli korzystasz z usługi LUIS po raz pierwszy, przewiń w dół strony powitalnej, aby znaleźć i kliknąć przycisk Utwórz aplikację usługi LUIS.

    Tworzenie strony aplikacji LUIS

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

    LUIS — obraz moje aplikacje

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

    LUIS — tworzenie nowej aplikacji

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

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

    • Intencja, reprezentuje metodę, która zostanie wywołana po zapytaniu od użytkownika. Intencja może mieć co najmniej jedną jednostkę.
    • Jednostka to składnik zapytania opisujący informacje dotyczące 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 dokładniej w tym rozdziale.

Rozpoczniesz od utworzenia jednostek potrzebnych do utworzenia tego kursu.

  1. W lewej części strony kliknij pozycję Jednostki, a następnie kliknij pozycję Utwórz nową jednostkę.

    Tworzenie nowej jednostki

  2. Wywołaj nowy kolor jednostki, ustaw jego typ na Simple (Prosta), a następnie naciśnij przycisk Done (Gotowe).

    Tworzenie prostej jednostki — kolor

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

    • Rozbudować
    • rozmiar downsize
    • Docelowego

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

Wynik tworzenia jednostki

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

Ostrzeżenie

Nie usuwaj intencji None.

  1. W lewej części strony kliknij pozycję Intents (Intencje), a następnie kliknij pozycję Create new intent (Utwórz nową intencję).

    Tworzenie nowych intencji

  2. Wywołaj nową intencję ChangeObjectColor.

    Ważne

    Ta nazwa intencji jest używana w kodzie w dalszej części tego kursu, więc aby uzyskać najlepsze wyniki, użyj tej nazwy dokładnie tak, jak podano.

Po potwierdzeniu nazwy zostaniesz skierowany do strony Intents (Intencje).

USŁUGA LUIS — strona intencji

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.

  1. Wstaw następującą wypowiedź w górnym polu tekstowym (obecnie z tekstem Wpisz około 5 przykładów... ), a następnie naciśnij klawisz Enter:
The color of the cylinder must be red

Zauważysz, że nowa wypowiedź pojawi się na liście poniżej.

W tym samym procesie 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 musisz określić, które słowa mają być używane przez usługi LUIS jako jednostki. W tym przykładzie należy oznaczać wszystkie kolory jako jednostkę koloru i wszystkie możliwe odwołania do obiektu docelowego jako jednostki docelowej.

  1. Aby to zrobić, spróbuj kliknąć wyraz cylindra w pierwszej wypowiedzi i wybrać element docelowy.

    Identyfikowanie celów wypowiedzi

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

    Identyfikowanie jednostek wypowiedzi

  3. Oznacz również następny wiersz etykietą, gdzie elementem docelowym powinien być moduł , a czarny powinien być kolorem. Zwróć również uwagę na użycie słów "this", "it" i "this object"(ten obiekt), które udostępniamy, tak aby dostępne były również nieokrejne typy docelowe.

  4. Powtarzaj powyższy proces, aż wszystkie wypowiedzi będą oznaczone etykietami Jednostki. Jeśli potrzebujesz pomocy, zobacz poniższy obraz.

    Porada

    Podczas wybierania wyrazów w celu etykietowania ich jako jednostek:

    • W przypadku pojedynczych wyrazów wystarczy je kliknąć.
    • Aby uzyskać zestaw dwóch lub większej liczby wyrazów, kliknij pozycję na początku, a następnie na końcu zestawu.

    Uwaga

    Możesz użyć przycisku przełączania Tokens View (Widok tokenów), aby przełączać się między widokiem Jednostki/Tokeny!

  5. Wyniki powinny być widoczne na poniższych ilustracjach i powinny być wyświetlane w widoku Jednostki/tokeny:

    Tokeny & widoków jednostek

  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 stanie się zielony. Oznacza to, że usługa LUIS została pomyślnie wytrenowana do rozpoznawania tej intencji.

    Szkolenie usługi LUIS

  7. W tym ćwiczeniu utworzysz nową intencję o nazwie ChangeObjectSize przy użyciu obiektów docelowych Entities , upsize i downsize.

  8. Zgodnie z tym samym procesem 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 być podobny do tego na poniższej ilustracji:

    Konfigurowanie tokenów/jednostek ChangeObjectSize

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

    Publikowanie usługi LUIS

  11. Na stronie Publikowanie sfinalizujemy i opublikujemy aplikację LUIS, aby można było uzyskać do niej dostęp za pomocą kodu.

    1. Ustaw listę rozwijaną Publish To (Publikuj do) jako produkcyjną.

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

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

    4. Kliknij pozycję Publish to Production Slot (Publikuj w miejscu produkcyjnym).

      Publikowanie Ustawienia

  12. W sekcji Zasoby i klucze:

    1. Wybierz region ustawiony dla wystąpienia usługi w witrynie Azure Portal.
    2. Zauważysz, że 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ą zalogowane do tego samego użytkownika, zostaną podane menu rozwijane nazwa dzierżawy, nazwa subskrypcji i klucz, którego chcesz użyć (będą mieć taką samą nazwę, jak podano wcześniej w witrynie Azure Portal.

    Ważne

    Poniżej pola Punkt końcowy skopiuj kopię punktu końcowego odpowiadającego wstawieniu klucza. Wkrótce użyjemy go w kodzie.

Rozdział 3 — Konfigurowanie projektu aparatu Unity

Poniżej przedstawiono typową infrastrukturę do tworzenia aplikacji w rzeczywistości mieszanej i dlatego jest to dobry szablon dla innych projektów.

  1. Otwórz platformę Unity i kliknij pozycję New (Nowy).

    Uruchom nowy projekt aparatu Unity.

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

    Podaj szczegółowe informacje dotyczące nowego projektu aparatu Unity.

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

    Aktualizowanie preferencji edytora skryptów.

  4. Następnie przejdź do pozycji File > Build Ustawienia and switch the platform to Universal Windows Platform(Platforma uniwersalna usługi Windows), klikając przycisk Switch Platform (Przełącz platformę).

    Kompilowanie Ustawienia, przełączanie platformy na platformę UWP.

  5. Przejdź do > kompilowania Ustawienia i upewnij się, że:

    1. Dla urządzenia docelowego ustawiono wartość 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ą wersję

    4. Visual Studio jest ustawiona na najnowszą zainstalowaną wersję

    5. Kompilowanie i uruchamianie jest ustawione na wartość Komputer lokalny

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

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

        Kliknij przycisk Dodaj otwarte sceny

      2. Utwórz dla tego folderu nowy folder i każdą przyszłą scenę, a następnie wybierz przycisk Nowy folder, aby utworzyć nowy folder i nadaj temu folderowi nazwę Scenes.

        Tworzenie nowego folderu skryptów

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

        Nadaj nowej scenie nazwę.

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

  6. W oknie Ustawienia kliknij przycisk Player Ustawienia, co spowoduje otwarcie powiązanego panelu w przestrzeni, w której znajduje się inspektor.

    Otwórz ustawienia odtwarzacza.

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

    1. Na karcie Inne Ustawienia danych:

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

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

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

        Zaktualizuj inne ustawienia.

    2. Na karcie Publishing Ustawienia (Możliwości) sprawdź:

      1. InternetClient

      2. Mikrofon

        Aktualizowanie ustawień publikowania.

    3. W dalszej część panelu, w Ustawienia XR (poniżej Ustawienia Publikowania), zaznacz pole wyboru Virtual Reality Supported(Obsługiwana rzeczywistość wirtualna) i upewnij się, że Windows Mixed Reality SDK.

      Zaktualizuj procesor X R Ustawienia.

  8. Po powrocie do kompilacji Ustawienia projektu C# aparatu Unity nie jest już wyszaryzowany; zaznacz pole wyboru obok tej.

  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 Konfigurowanie aparatu Unity w tym kursie i przejść bezpośrednio do kodu, możesz pobrać ten pakiet unitypackage,zaimportować go do projektu jako pakiet niestandardowy,a następnie kontynuować od rozdziału 5.

  1. Kliknij prawym przyciskiem myszy w pustym obszarze panelu hierarchii w obszarze Obiekt 3D i dodaj płaszczyznę.

    Utwórz płaszczyznę.

  2. Należy pamiętać, że po kliknięciu prawym przyciskiem myszy w hierarchii ponownie w celu utworzenia większej liczby obiektów, jeśli nadal jest wybrany ostatni obiekt, wybrany obiekt będzie obiektem nadrzędnym nowego obiektu. Unikaj klikania lewym przyciskiem myszy pustego miejsca w hierarchii, a następnie klikania prawym przyciskiem myszy.

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

    1. Kula
    2. Cylinder
    3. Sześcian
    4. Tekst 3D
  4. Wynikowa hierarchia sceny powinna wyglądać podobnie do tej na poniższej ilustracji:

    Konfiguracja hierarchii sceny.

  5. Kliknij lewym przyciskiem myszy pozycję Main Camera (Kamera główna), aby ją wybrać. Na panelu Inspector (Inspektor) zobaczysz obiekt Camera (Aparat) ze wszystkimi jego składnikami.

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

    Dodawanie źródła audio

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

  8. Upewnij się również, że dla składnika Przekształć głównego aparatu ustawiono wartość (0,0,0). Można to zrobić, naciskając ikonę Koła zębatego obok składnika Przekształcenie aparatu i wybierając pozycję Resetuj. Składnik Przekształć powinien wyglądać tak:

    1. Pozycja jest ustawiona na 0, 0, 0.
    2. Rotacja jest ustawiona na 0, 0, 0.

    Uwaga

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

    • Wyczyść flagi: Pełny kolor.
    • Tło "Czarny, Alfa 0" — kolor hex: #00000000.
  9. Kliknij lewym przyciskiem myszy płaszczyznę, aby ją zaznaczyć. Na panelu Inspektor ustaw składnik Przekształć przy użyciu następujących wartości:

    Oś X Oś Y Osi
    0 -1 0
  10. Kliknij lewym przyciskiem myszy pozycję Sphere, aby ją wybrać. Na panelu Inspektor ustaw składnik Przekształć przy użyciu następujących wartości:

    Oś X Oś Y Osi
    2 1 2
  11. Kliknij lewym przyciskiem myszy cylindr, aby go wybrać. Na panelu Inspektor ustaw składnik Przekształć przy użyciu następujących wartości:

    Oś X Oś Y Osi
    -2 1 2
  12. Kliknij lewym przyciskiem myszy sześcian, aby go wybrać. Na panelu Inspektor ustaw składnik Przekształć przy użyciu następujących wartości:

    Przekształć — położenie | Przekształcanie — rotacja
    X Y Z | X Y Z
    0 1 4 | 45 45 0
  13. Kliknij lewym przyciskiem myszy obiekt Nowy tekst, aby go zaznaczyć. Na panelu Inspektor ustaw składnik Przekształć przy użyciu następujących wartości:

    Przekształć — położenie | Przekształcanie — skalowanie
    X Y Z | X Y Z
    -2 6 9 | 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.

    Tworzenie obiektu 3D Text

  16. Struktura panelu hierarchii powinna teraz wyglądać tak:

    siatka tekstu w widoku sceny

  17. Ostatnia scena powinna wyglądać jak na poniższej ilustracji:

    Widok sceny.

Rozdział 5 — Tworzenie klasy MicrophoneManager

Pierwszym skryptem, który utworzysz, jest klasa MicrophoneManager. Następnie utworzysz klasę LuisManager, klasę Behaviours i na koniec klasę Gaze (możesz teraz utworzyć wszystkie te elementy, chociaż zostaną one uwzględnione w każdym rozdziale).

Klasa MicrophoneManager jest odpowiedzialna za:

  • Wykrywanie urządzenia rejestrującego podłączonego do zestawu nagłownego lub komputera (w zależności od tego, który z nich jest domyślny).
  • 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 Project pozycję Utwórz > folder . Wywołaj folder Skrypty.

    Utwórz folder Skrypty.

  2. Po utworzeniu folderu Skrypty kliknij go dwukrotnie, aby go otworzyć. Następnie w tym folderze kliknij prawym przyciskiem myszy pozycję Utwórz skrypt > 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. Należy teraz dodać kod dla metod Awake() i Start(). Zostaną one wywołane podczas inicjowania klasy:

        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óra zostanie wkrótce skompilowana.

        /// <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 zostanie wywołany po wstrzymaniu głosu. Ta metoda przekaże tekst dyktowania do klasy LuisManager.

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

    Ważne

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

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

    Uwaga

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

Rozdział 6 — Tworzenie klasy LUISManager

Na czas utworzysz 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, który ma zostać przeanalizowany.

Ta klasa deserializuje odpowiedź JSON i wywołuje odpowiednie metody klasy Zachowań, aby wyzwolić akcję.

Aby utworzyć tę klasę:

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

  2. Kliknij prawym przyciskiem myszy wewnątrz folderu Skrypty, a następnie kliknij polecenie > 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ć zdeserializowana 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 teraz umieść punkt końcowy usługi LUIS (który będzie dostępny w portalu usługi LUIS).

  8. Należy teraz dodać kod metody Awake(). Ta metoda zostanie wywołana podczas inicjowania klasy:

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  9. Teraz potrzebne są metody, których ta aplikacja używa do wysyłania dyktowania odebranego z klasy MicrophoneManager do usługi LUIS, a następnie odbierania i deserialiizacji odpowiedzi.

  10. Po skojarzoną wartość intencji i skojarzonych jednostek są one przekazywane do wystąpienia klasy Zachowań 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 AnalyseResponseElements(), która odczyta wynikowy element Query i określi jednostki. Gdy te jednostki zostaną określone, zostaną one przekazane do wystąpienia klasy Zachowań do użycia w akcjach.

        private void AnalyseResponseElements(AnalysedQuery aQuery)
        {
            string topIntent = aQuery.topScoringIntent.intent;
    
            // Create a dictionary of entities associated with their type
            Dictionary<string, string> entityDic = new Dictionary<string, string>();
    
            foreach (EntityData ed in aQuery.entities)
            {
                entityDic.Add(ed.type, ed.entity);
            }
    
            // Depending on the topmost recognized intent, read the entities name
            switch (aQuery.topScoringIntent.intent)
            {
                case "ChangeObjectColor":
                    string targetForColor = null;
                    string color = null;
    
                    foreach (var pair in entityDic)
                    {
                        if (pair.Key == "target")
                        {
                            targetForColor = pair.Value;
                        }
                        else if (pair.Key == "color")
                        {
                            color = pair.Value;
                        }
                    }
    
                    Behaviours.instance.ChangeTargetColor(targetForColor, color);
                    break;
    
                case "ChangeObjectSize":
                    string targetForSize = null;
                    foreach (var pair in entityDic)
                    {
                        if (pair.Key == "target")
                        {
                            targetForSize = pair.Value;
                        }
                    }
    
                    if (entityDic.ContainsKey("upsize") == true)
                    {
                        Behaviours.instance.UpSizeTarget(targetForSize);
                    }
                    else if (entityDic.ContainsKey("downsize") == true)
                    {
                        Behaviours.instance.DownSizeTarget(targetForSize);
                    }
                    break;
            }
        }
    

    Ważne

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

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

Uwaga

W tym momencie w panelu konsoli edytora aparatu Unity zostanie wyświetlonych kilka błędów. Wynika to z tego, że kod odwołuje się do klasy Zachowań, którą utworzysz w następnym rozdziale.

Rozdział 7 — Tworzenie klasy Zachowań

Klasa Zachowań 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 Skrypty, a następnie kliknij polecenie > skrypt języka C#. Nadaj skryptowi nazwę Zachowania.

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

  4. Następnie dodaj następujące zmienne wewnątrz klasy Zachowań:

        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 podczas inicjowania klasy:

        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óry obiekt GameObjects jest obiektem docelowym bieżącej intencji. Ta metoda domyślnie określa element docelowy obiektu GameObject jako "wpatrzony", 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 programie Visual Studio przed powrotem do aparatu Unity.

Rozdział 8 — tworzenie klasy spojrzenia

Ostatnią klasą, która będzie potrzebna do ukończenia tej aplikacji, jest klasa Gaze. Ta klasa aktualizuje odwołanie do gameObject aktualnie w fokusie wizualnym użytkownika.

Aby utworzyć tę klasę:

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

  2. Kliknij prawym przyciskiem myszy wewnątrz folderu Skrypty, a następnie kliknij polecenie > 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 programie Visual Studio przed powrotem do aparatu Unity.

Rozdział 9 — Kończenie konfiguracji sceny

  1. Aby ukończyć konfigurację sceny, przeciągnij każdy utworzony skrypt z folderu Skrypty do obiektu Main Camera (Kamera główna) w Panelu hierarchii.

  2. Wybierz pozycję Main Camera (Kamera główna) i spójrz na panel Inspector (Inspektor), aby wyświetlić każdy dołączony skrypt. Zauważysz, że w każdym skrypcie istnieją parametry, które nie zostały jeszcze ustawione.

    Ustawianie obiektów docelowych odwołania aparatu.

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

    1. MicrophoneManager:

      • Z Panelu hierarchii przeciągnij obiekt Dictation Text (Tekst dyktowania) do pola wartości parametru Dictation Text (Tekst dyktowania).
    2. Zachowania , z Panelu hierarchii:

      • Przeciągnij obiekt Sphere do pola docelowego odwołania do sfery.
      • Przeciągnij cylindr do pola docelowego odwołania cylindra.
      • Przeciągnij sześcian do pola docelowego odwołania do modułu.
    3. Spojrzenie:

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

    Wyświetlanie obiektów docelowych odwoływujących się do aparatu, teraz ustawionych.

Rozdział 10 — testowanie w edytorze aparatu Unity

Sprawdź, czy konfiguracja sceny jest prawidłowo zaimplementowana.

Upewnij się, że:

  • Wszystkie skrypty są dołączone do obiektu Main Camera (Kamera główna).
  • Wszystkie pola na głównym panelu inspektora kamery są prawidłowo przypisane.
  1. Naciśnij przycisk Odtwarzania w edytorze aparatu Unity. Aplikacja powinna być uruchomiona w dołączonym immersyjnym zestawie nagłownym.

  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 o zmianie 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 nagłownych, 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 boczne rozwiązania platformy uniwersalnej systemu Windows

Po upewnienia się, że aplikacja działa w edytorze aparatu Unity, możesz rozpocząć tworzenie i wdrażanie.

Aby skompilować:

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

  2. Przejdź do pliku > kompilacji Ustawienia.

  3. Zaznacz pole o nazwie Projekty języka C# aparatu Unity (przydatne do zobaczenia i debugowania kodu po utworzeniu projektu platformy uniwersalnej systemu Windows).

  4. Kliknij pozycję Add Open Scenes (Dodaj otwarte sceny), a następnie kliknij pozycję Build (Skompilowanie).

    Okno Ustawienia kompilacji

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

  6. Utwórz folder BUILDS i w tym folderze utwórz inny folder o wybranej nazwie.

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

    Create Builds Folder Select Builds Folder (Tworzenie folderu  kompilacji) Select Builds Folder (Wybieranie folderu kompilacji)

  8. Po zakończeniu tworzenia aparatu 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, który został utworzony w poprzednim rozdziale.

  2. Na platformie rozwiązania wybierz pozycję x86, Komputer lokalny.

  3. W konfiguracji rozwiązania wybierz pozycję Debuguj.

    W przypadku Microsoft HoloLens można łatwiej ustawić tę wartość na Komputer zdalny, aby nie naiązywał się z komputerem. Należy jednak również wykonać następujące czynności:

    • Należy znać adres IP serwera HoloLens, który można znaleźć w obszarze Ustawienia > Network & Opcje > Wi-Fi > zaawansowane; Adres IPv4 to adres, który należy użyć.
    • Upewnij się, że tryb dewelopera jest wł.; znajduje się w Ustawienia > Update & Security > For developers (Aktualizacja usługi Update > Security > dla deweloperów).

    Wdrażanie aplikacji

  4. Przejdź do menu Kompilacja i kliknij pozycję Deploy Solution (Wd wdrażaj rozwiązanie), aby załadować aplikację na komputer.

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

  6. Po jej zakończeniu aplikacja wyświetli monit o autoryzowanie dostępu do mikrofonu. Naciśnij przycisk YES (Tak) za pomocą kontrolerów ruchu, głosu wejściowego lub klawiatury.

Rozdział 12 — Ulepszanie usługi LUIS

Ważne

Ten rozdział jest niezwykle ważny i może wymagać kilkukrotnie wykonania iterowania, ponieważ pomoże to zwiększyć dokładność usługi LUIS: upewnij się, że to zpełnisz.

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

Możesz na przykład wytrenować aplikację LUIS, aby zrozumiała "Zwiększ" i "Zwiększ rozmiar", ale czy chcesz, aby aplikacja również zrozumiała wyrazy takie jak "Powiększ"?

Gdy aplikacja zostanie użyta kilka razy, wszystko, co już wiesz, będzie zbierane przez aplikację LUIS i dostępne w portalu usługi LUIS.

  1. Przejdź do aplikacji portalu, po tym linku izaloguj się.

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

  3. Kliknij przycisk Review endpoint utterances (Przejrzyj wypowiedzi punktu końcowego) po lewej stronie.

    Przeglądanie wypowiedzi

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

    Lista wypowiedzi

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

Umieszczając wskaźnik myszy na każdym wyróżniony wyraz, 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 "spear" zostało wyróżnione jako element docelowy, więc konieczne jest poprawienie błędu, co jest wykonywane przez umieszczenie wskaźnika myszy na wyrazie i kliknięcie przycisku Usuń etykietę.

Sprawdzanie wypowiedzi Usuwanie obrazu  etykiety

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

    Usuwanie nieprawidłowych wypowiedzi

  2. Jeśli uważasz, że usługa LUIS prawidłowo zinterpretowała wypowiedź, możesz zweryfikować jej interpretację przy użyciu przycisku Dodaj do wyrównanych intencji.

    Dodawanie do wyrównanych intencji

  3. Po posortowaniu wszystkich wyświetlanych wypowiedzi spróbuj ponownie załadować stronę, aby sprawdzić, czy jest ich więcej.

  4. Bardzo ważne jest, aby powtarzać ten proces jak najwięcej razy, aby lepiej zrozumieć aplikację.

Baw się dobrze!

Ukończona zintegrowana aplikacja usługi LUIS

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

Wynik laboratorium

Ćwiczenia dodatkowe

Ćwiczenie 1

Korzystając z tej aplikacji, możesz zauważyć, że jeśli spojrzysz 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 Spojrzenia, w zależności od tego, co mówi użytkownik, a następnie możesz używać tych obiektów razem z bieżącymi obiektami sceny przy użyciu istniejących poleceń.