HoloLens (1ère génération) et Azure 303 : Compréhension du langage naturel (LUIS)


Notes

Les tutoriels Mixed Reality Academy ont été conçus pour les appareils HoloLens (1re génération) et les casques immersifs de réalité mixte. Nous estimons qu’il est important de laisser ces tutoriels à la disposition des développeurs qui recherchent encore des conseils pour développer des applications sur ces appareils. Notez que ces tutoriels ne sont pas mis à jour avec les derniers ensembles d’outils ou interactions utilisés pour HoloLens 2. Ils sont fournis dans le but de fonctionner sur les appareils pris en charge. Il y aura une nouvelle série de tutoriels qui seront publiés à l’avenir qui montreront comment développer pour HoloLens 2. Cet avis sera mis à jour avec un lien vers ces didacticiels lorsqu’ils sont publiés.


Dans ce cours, vous allez apprendre à intégrer Language Understanding dans une application de réalité mixte à l’aide d’Azure Cognitive Services, avec l’API Language Understanding.

Lab outcome

Language Understanding (LUIS) est un service de Microsoft Azure, qui fournit aux applications la possibilité de tirer le sens de l’entrée utilisateur, par exemple en extrayant ce qu’une personne peut vouloir, en ses propres mots. Cette opération est obtenue par le biais du Machine Learning, qui comprend et apprend les informations d’entrée, puis peut répondre avec des informations détaillées, pertinentes et pertinentes. Pour plus d’informations, consultez la page Azure Language Understanding (LUIS).

Après avoir terminé ce cours, vous aurez une application de casque immersif de réalité mixte qui sera en mesure d’effectuer les opérations suivantes :

  1. Capturez la parole d’entrée utilisateur à l’aide du microphone attaché au casque immersif.
  2. Envoyez la dictée capturée au service intelligent Azure Language Understanding (LUIS).
  3. Demandez à LUIS d’extraire la signification des informations d’envoi, qui seront analysées et de tenter de déterminer l’intention de la demande de l’utilisateur.

Le développement inclut la création d’une application dans laquelle l’utilisateur pourra utiliser la voix et/ou le regard pour modifier la taille et la couleur des objets de la scène. L’utilisation des contrôleurs de mouvement ne sera pas couverte.

Dans votre application, il vous incombe de savoir comment intégrer les résultats à votre conception. Ce cours est conçu pour vous apprendre à intégrer un service Azure à votre Project Unity. C’est votre travail d’utiliser les connaissances que vous obtenez de ce cours pour améliorer votre application de réalité mixte.

Soyez prêt à former LUIS plusieurs fois, qui est couvert au chapitre 12. Vous obtiendrez de meilleurs résultats plus de fois LUIS a été formé.

Prise en charge des appareils

Cours HoloLens Casques immersifs
MR et Azure 303 : Compréhension du langage naturel (LUIS) ✔️ ✔️

Notes

Bien que ce cours se concentre principalement sur Windows Mixed Reality casques immersifs (VR), vous pouvez également appliquer ce que vous apprenez dans ce cours à Microsoft HoloLens. À mesure que vous suivez le cours, vous verrez des notes sur les modifications que vous devrez peut-être utiliser pour prendre en charge HoloLens. Lorsque vous utilisez HoloLens, vous pouvez remarquer un écho lors de la capture vocale.

Prérequis

Notes

Ce didacticiel est conçu pour les développeurs qui ont une expérience de base avec Unity et C#. Sachez également que les conditions préalables et les instructions écrites de ce document représentent ce qui a été testé et vérifié au moment de l’écriture (mai 2018). Vous êtes libre d’utiliser le logiciel le plus récent, comme indiqué dans l’article d’installation des outils , bien qu’il ne soit pas supposé que les informations de ce cours correspondent parfaitement à ce que vous trouverez dans les logiciels plus récents que ceux répertoriés ci-dessous.

Nous vous recommandons le matériel et les logiciels suivants pour ce cours :

Avant de commencer

  1. Pour éviter de rencontrer des problèmes lors de la création de ce projet, il est fortement recommandé de créer le projet mentionné dans ce didacticiel dans un dossier racine ou proche (des chemins de dossier longs peuvent provoquer des problèmes au moment de la génération).

  2. Pour permettre à votre ordinateur d’activer la dictée, accédez à Windows Paramètres > Privacy > Speech, Saisie manuscrite & et appuyez sur le bouton Activer les services vocaux et taper des suggestions.

  3. Le code de ce tutoriel vous permet d’enregistrer à partir de l’appareil microphone par défaut défini sur votre ordinateur. Vérifiez que l’appareil microphone par défaut est défini comme celui que vous souhaitez utiliser pour capturer votre voix.

  4. Si votre casque a un microphone intégré, assurez-vous que l’option « Lorsque je porte mon casque, basculez vers le micro du casque » est activée dans les paramètres du portail Mixed Reality.

    Setting up immersive headset

Chapitre 1 : Configurer le portail Azure

Pour utiliser le service Language Understanding dans Azure, vous devez configurer une instance du service à rendre disponible pour votre application.

  1. Connectez-vous au portail Azure.

    Notes

    Si vous n’avez pas encore de compte Azure, vous devez en créer un. Si vous suivez ce tutoriel dans une situation de salle de classe ou de laboratoire, demandez à votre instructeur ou à l’un des proctors d’aider à configurer votre nouveau compte.

  2. Une fois que vous êtes connecté, cliquez sur Nouveau dans le coin supérieur gauche, puis recherchezLanguage Understanding, puis cliquez sur Entrée.

    Create LUIS resource

    Notes

    Le mot Nouveau peut avoir été remplacé par Créer une ressource dans des portails plus récents.

  3. La nouvelle page à droite fournit une description du service Language Understanding. En bas à gauche de cette page, sélectionnez le bouton Créer pour créer une instance de ce service.

    LUIS service creation - legal notice

  4. Une fois que vous avez cliqué sur Créer :

    1. Insérez le nom souhaité pour cette instance de service.

    2. Sélectionnez un Abonnement.

    3. Sélectionnez le niveau tarifaire approprié pour vous, si c’est la première fois que vous créez un service LUIS, un niveau gratuit (nommé F0) doit être disponible pour vous. L’allocation gratuite devrait être plus que suffisante pour ce cours.

    4. Choisissez un groupe de ressources ou créez-en un. Un groupe de ressources permet de surveiller, contrôler l’accès, provisionner et gérer la facturation d’une collection de ressources Azure. Il est recommandé de conserver tous les services Azure associés à un seul projet (par exemple, ces cours) sous un groupe de ressources commun).

      Si vous souhaitez en savoir plus sur les groupes de ressources Azure, consultez l’article du groupe de ressources.

    5. Déterminez l’emplacement de votre groupe de ressources (si vous créez un groupe de ressources). L’emplacement se trouve idéalement dans la région où l’application s’exécute. Certaines ressources Azure sont disponibles uniquement dans certaines régions.

    6. Vous devrez également confirmer que vous avez compris les conditions générales appliquées à ce service.

    7. Sélectionnez Create (Créer).

      Create LUIS service - user input

  5. Une fois que vous avez cliqué sur Créer, vous devrez attendre la création du service, ce qui peut prendre une minute.

  6. Une notification s’affiche dans le portail une fois l’instance de service créée.

    New Azure notification image

  7. Cliquez sur la notification pour explorer votre nouvelle instance de service.

    Successful resource creation notification

  8. Cliquez sur le bouton Accéder à la ressource dans la notification pour explorer votre nouvelle instance de service. Vous êtes dirigé vers votre nouvelle instance de service LUIS.

    Accessing LUIS Keys

  9. Dans ce tutoriel, votre application doit effectuer des appels à votre service, ce qui est effectué à l’aide de la clé d’abonnement de votre service.

  10. Dans la page Démarrage rapide , de votre service d’API LUIS , accédez à la première étape, saisissez vos clés et cliquez sur Clés (vous pouvez également le faire en cliquant sur les touches de lien hypertexte bleues, situées dans le menu de navigation des services, indiquée par l’icône de touche). Cela révélera vos clés de service.

  11. Prenez une copie de l’une des clés affichées, car vous en aurez besoin plus tard dans votre projet.

  12. Dans la page Service, cliquez sur Language Understanding Portail pour être redirigé vers la page web que vous utiliserez pour créer votre nouveau service, dans l’application LUIS.

Chapitre 2 : Portail Language Understanding

Dans cette section, vous allez apprendre à créer une application LUIS sur le portail LUIS.

Important

N’oubliez pas que la configuration des entités, intentions et énoncés dans ce chapitre n’est que la première étape de la création de votre service LUIS : vous devrez également réentraîner le service, plusieurs fois, afin de le rendre plus précis. La réentraînation de votre service est couverte dans le dernier chapitre de ce cours, afin de vous assurer que vous l’avez terminé.

  1. Lorsque vous atteignez le portail Language Understanding, vous devrez peut-être vous connecter, si vous n’êtes pas déjà, avec les mêmes informations d’identification que votre Portail Azure.

    LUIS login page

  2. S’il s’agit de votre première utilisation de LUIS, vous devez faire défiler vers le bas de la page d’accueil, pour rechercher et cliquer sur le bouton Créer une application LUIS .

    Create LUIS app page

  3. Une fois connecté, cliquez sur Mes applications (si vous n’êtes pas dans cette section actuellement). Vous pouvez ensuite cliquer sur Créer une application.

    LUIS - my apps image

  4. Attribuez un nom à votre application.

  5. Si votre application est censée comprendre une langue différente de l’anglais, vous devez changer la culture en langue appropriée.

  6. Ici, vous pouvez également ajouter une description de votre nouvelle application LUIS.

    LUIS - create a new app

  7. Une fois que vous appuyez sur Terminé, vous entrez dans la page Build de votre nouvelle application LUIS .

  8. Voici quelques concepts importants à comprendre :

    • Intention, représente la méthode qui sera appelée à la suite d’une requête de l’utilisateur. Une INTENTION peut avoir une ou plusieurs ENTITÉS.
    • Entité, est un composant de la requête qui décrit les informations pertinentes pour l’INTENTION.
    • Les énoncés sont des exemples de requêtes fournies par le développeur, que LUIS utilisera pour s’entraîner lui-même.

Si ces concepts ne sont pas parfaitement clairs, ne vous inquiétez pas, car ce cours les clarifiera plus loin dans ce chapitre.

Vous allez commencer par créer les entités nécessaires pour générer ce cours.

  1. Sur le côté gauche de la page, cliquez sur Entités, puis sur Créer une entité.

    Create new entity

  2. Appelez la nouvelle couleur d’entité, définissez son type sur Simple, puis appuyez sur Terminé.

    Create simple entity - color

  3. Répétez ce processus pour créer trois (3) entités simples nommées :

    • upsize
    • Réduire
    • cible

Le résultat doit ressembler à l’image ci-dessous :

Result of entity creation

À ce stade, vous pouvez commencer à créer des intentions.

Avertissement

Ne supprimez pas l’intention None .

  1. Sur le côté gauche de la page, cliquez sur Intentions, puis sur Créer une intention.

    Create new intents

  2. Appelez la nouvelle IntentChangeObjectColor.

    Important

    Ce nom d’intention est utilisé dans le code plus loin dans ce cours. Pour obtenir les meilleurs résultats, utilisez ce nom exactement comme indiqué.

Une fois que vous confirmez le nom que vous êtes dirigé vers la page Intentions.

LUIS - intents page

Vous remarquerez qu’il existe une zone de texte qui vous demande de taper 5 ou plusieurs énoncés différents.

Notes

LUIS convertit tous les énoncés en minuscules.

  1. Insérez l’énoncé suivant dans la zone de texte supérieure (actuellement avec le type de texte sur 5 exemples... ), puis appuyez sur Entrée :
The color of the cylinder must be red

Vous remarquerez que le nouvel énoncé s’affiche dans une liste en dessous.

Après le même processus, insérez les six (6) énoncés suivants :

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

Pour chaque énoncé que vous avez créé, vous devez identifier les mots qui doivent être utilisés par LUIS en tant qu’entités. Dans cet exemple, vous devez étiqueter toutes les couleurs en tant qu’entité de couleur et toutes les références possibles à une cible en tant qu’entité cible .

  1. Pour ce faire, essayez de cliquer sur le cylindre de mot dans le premier énoncé et de sélectionner la cible.

    Identify Utterance Targets

  2. Cliquez maintenant sur le mot rouge dans le premier énoncé et sélectionnez la couleur.

    Identify Utterance Entities

  3. Étiquettez également la ligne suivante, où le cube doit être une cible et le noir doit être une couleur. Notez également l’utilisation des mots « this », « it» et « this object », que nous fournissons, afin d’avoir des types cibles non spécifiques disponibles également.

  4. Répétez le processus ci-dessus jusqu’à ce que tous les énoncés aient les entités étiquetées. Consultez l’image ci-dessous si vous avez besoin d’aide.

    Conseil

    Lorsque vous sélectionnez des mots pour les étiqueter en tant qu’entités :

    • Pour les mots simples, cliquez simplement sur eux.
    • Pour un ensemble de deux mots ou plus, cliquez au début, puis à la fin de l’ensemble.

    Notes

    Vous pouvez utiliser le bouton bascule de l’affichage Jetons pour basculer entre les entités / vue Jetons !

  5. Les résultats doivent être vus dans les images ci-dessous, montrant l’affichage Entités /Jetons :

    Tokens & Entities Views

  6. À ce stade, appuyez sur le bouton Train en haut à droite de la page et attendez que le petit indicateur arrondi sur celui-ci soit en vert. Cela indique que LUIS a été formé avec succès pour reconnaître cette intention.

    Train LUIS

  7. En tant qu’exercice pour vous, créez une intention appelée ChangeObjectSize, à l’aide de la cible d’entités, de la montée en puissance et de la baisse.

  8. Suivant le même processus que l’intention précédente, insérez les huit (8) énoncés suivants pour la modification de taille :

    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. Le résultat doit être semblable à celui de l’image ci-dessous :

    Setup the ChangeObjectSize Tokens/ Entities

  10. Une fois les intentions, ChangeObjectColor et ChangeObjectSize ont été créés et entraînés, cliquez sur le bouton PUBLIER en haut de la page.

    Publish LUIS service

  11. Dans la page Publier , vous allez finaliser et publier votre application LUIS afin qu’elle soit accessible par votre code.

    1. Définissez la liste déroulante Publier en tant que production.

    2. Définissez le fuseau horaire sur votre fuseau horaire.

    3. Cochez la case Inclure tous les scores d’intention prédits.

    4. Cliquez sur Publier dans l’emplacement de production.

      Publish Settings

  12. Dans la section Ressources et clés :

    1. Sélectionnez la région que vous définissez pour l’instance de service dans le portail Azure.
    2. Vous remarquerez un élément Starter_Key ci-dessous, ignorez-le.
    3. Cliquez sur Ajouter une clé et insérez la clé que vous avez obtenue dans le portail Azure lorsque vous avez créé votre instance de service. Si votre portail Azure et le portail LUIS sont connectés au même utilisateur, vous serez fourni des menus déroulants pour le nom du locataire, le nom de l’abonnement et la clé que vous souhaitez utiliser (aura le même nom que celui que vous avez fourni précédemment dans le portail Azure.

    Important

    Sous le point de terminaison, prenez une copie du point de terminaison correspondant à la clé que vous avez insérée, vous l’utiliserez bientôt dans votre code.

Chapitre 3 : Configurer le projet Unity

Voici une configuration classique pour le développement avec la réalité mixte, et par conséquent, est un bon modèle pour d’autres projets.

  1. Ouvrez Unity , puis cliquez sur Nouveau.

    Start new Unity project.

  2. Vous devez maintenant fournir un nom de Project Unity, insérer MR_LUIS. Vérifiez que le type de projet est défini sur 3D. Définissez l’emplacement sur un emplacement approprié pour vous (n’oubliez pas que les répertoires racines sont meilleurs). Ensuite, cliquez sur Créer un projet.

    Provide details for new Unity project.

  3. Avec Unity ouvert, il vaut la peine de vérifier que l’éditeur de script par défaut est défini sur Visual Studio. Accédez à Modifier > les préférences, puis à partir de la nouvelle fenêtre, accédez aux outils externes. Modifiez l’éditeur de script externeen Visual Studio 2017. Fermez la fenêtre Préférences .

    Update script editor preference.

  4. Ensuite, accédez à La génération de fichiers > Paramètres et basculez la plateforme vers plateforme Windows universelle, en cliquant sur le bouton Basculer la plateforme.

    Build Settings window, switch platform to UWP.

  5. Accédez à La build de fichiers > Paramètres et assurez-vous que :

    1. L’appareil cible est défini sur n’importe quel appareil

      Pour le Microsoft HoloLens, définissez l’appareil ciblesur HoloLens.

    2. Le type de build est défini sur D3D

    3. Le Kit de développement logiciel (SDK) est défini sur La dernière version installée

    4. Visual Studio version est définie sur La dernière version installée

    5. La génération et l’exécution sont définies sur ordinateur local

    6. Enregistrez la scène et ajoutez-la à la build.

      1. Pour ce faire, sélectionnez Ajouter des scènes d’ouverture. Une fenêtre d’enregistrement s’affiche.

        Click add open scenes button

      2. Créez un dossier pour cela et toute scène future, puis sélectionnez le bouton Nouveau dossier pour créer un dossier, nommez-le Scène.

        Create new scripts folder

      3. Ouvrez votre dossier Scènes nouvellement créé, puis, dans le nom du fichier : champ de texte, tapez MR_LuisScene, puis appuyez sur Enregistrer.

        Give new scene a name.

    7. Les paramètres restants, dans Build Paramètres, doivent être laissés comme valeur par défaut pour l’instant.

  6. Dans la fenêtre Build Paramètres, cliquez sur le bouton Lecteur Paramètres, ce qui ouvre le panneau associé dans l’espace où se trouve l’Inspecteur.

    Open player settings.

  7. Dans ce panneau, quelques paramètres doivent être vérifiés :

    1. Sous l’onglet Autres Paramètres :

      1. La version du runtime de script doit être stable (équivalent.NET 3.5).

      2. Le serveur principal de script doit être .NET

      3. Le niveau de compatibilité de l’API doit être .NET 4.6

        Update other settings.

    2. Sous l’onglet Publication Paramètres, sous Fonctionnalités, cochez :

      1. InternetClient

      2. Microphone

        Updating publishing settings.

    3. Plus loin dans le panneau, dans XR Paramètres (trouvé ci-dessous Publier Paramètres), cochez Virtual Reality Pris en charge, vérifiez que le Kit de développement logiciel (SDK) Windows Mixed Reality est ajouté.

      Update the X R Settings.

  8. Retour dans Build ParamètresUnity C# Projects n’est plus grisé ; cochez la case en regard de cela.

  9. Fermez la fenêtre Build Settings.

  10. Enregistrez votre scène et Project (>FILE SAVE SCENE / FILE > SAVE PROJECT).

Chapitre 4 : Créer la scène

Important

Si vous souhaitez ignorer le composant Configuration Unity de ce cours et continuer directement dans le code, n’hésitez pas à télécharger ce .unitypackage, importez-le dans votre projet en tant que package personnalisé, puis continuez à partir du chapitre 5.

  1. Cliquez avec le bouton droit dans une zone vide du panneau hiérarchie, sous l’objet 3D, ajoutez un plan.

    Create a plane.

  2. N’oubliez pas que lorsque vous cliquez avec le bouton droit dans la hiérarchie pour créer davantage d’objets, si vous avez toujours le dernier objet sélectionné, l’objet sélectionné sera le parent de votre nouvel objet. Évitez ce clic gauche dans un espace vide dans la hiérarchie, puis cliquez avec le bouton droit.

  3. Répétez la procédure ci-dessus pour ajouter les objets suivants :

    1. Sphere
    2. Cylindre
    3. Cube
    4. Texte 3D
  4. La hiérarchie de scène résultante doit être semblable à celle de l’image ci-dessous :

    Scene Hierarchy setup.

  5. Cliquez avec le bouton gauche sur la caméra principale pour le sélectionner, regardez le Panneau inspecteur que vous verrez l’objet Caméra avec tous ses composants.

  6. Cliquez sur le bouton Ajouter un composant situé en bas du panneau Inspecteur.

    Add Audio Source

  7. Recherchez le composant appelé Source audio, comme indiqué ci-dessus.

  8. Assurez-vous également que le composant Transformer de la caméra principale est défini sur (0,0,0), cela peut être effectué en appuyant sur l’icône Engrenage en regard du composant Transformation de l’appareil photo et en sélectionnant Réinitialiser. Le composant Transform doit ensuite ressembler à ceci :

    1. La position est définie sur 0, 0, 0.
    2. La rotation est définie sur 0, 0, 0.

    Notes

    Pour le Microsoft HoloLens, vous devez également modifier les éléments suivants, qui font partie du composant Caméra, qui se trouve sur votre appareil photo principal :

    • Effacer les indicateurs : Couleur unie.
    • Fond 'Black, Alpha 0' – Couleur hex : #0000000000.
  9. Cliquez avec le bouton gauche sur le plan pour le sélectionner. Dans le panneau Inspecteur , définissez le composant Transformation avec les valeurs suivantes :

    Axe X Axe Y Axe Z
    0 -1 0
  10. Cliquez sur La sphère pour la sélectionner. Dans le panneau Inspecteur , définissez le composant Transformation avec les valeurs suivantes :

    Axe X Axe Y Axe Z
    2 1 2
  11. Cliquez avec le bouton gauche sur le cylindre pour le sélectionner. Dans le panneau Inspecteur , définissez le composant Transformation avec les valeurs suivantes :

    Axe X Axe Y Axe Z
    -2 1 2
  12. Cliquez avec le bouton gauche sur le cube pour le sélectionner. Dans le panneau Inspecteur , définissez le composant Transformation avec les valeurs suivantes :

    Transformation - Position | Transformation - Rotation
    X O Z | X O Z
    0 1 4 | 45 45 0
  13. Cliquez sur l’objet Nouveau texte pour le sélectionner. Dans le panneau Inspecteur , définissez le composant Transformation avec les valeurs suivantes :

    Transformation - Position | Transformation - Mise à l’échelle
    X O Z | X O Z
    -2 6 9 | 0.1 0.1 0.1
  14. Modifiez la taille de police dans le composant Text Mesh sur 50.

  15. Remplacez le nom de l’objet Text Mesh par Dictée Text.

    Create 3D Text object

  16. Votre structure de panneau hiérarchie doit maintenant ressembler à ceci :

    text mesh in scene view

  17. La scène finale doit ressembler à l’image ci-dessous :

    The scene view.

Chapitre 5 : Créer la classe MicrophoneManager

Le premier script que vous allez créer est la classe MicrophoneManager . Après cela, vous allez créer la classe LuisManager, la classe Comportement et enfin la classe Regard ( n’hésitez pas à créer tous ces éléments maintenant, bien qu’elle soit couverte à mesure que vous atteignez chaque chapitre).

La classe MicrophoneManager est responsable des opérations suivantes :

  • Détection de l’appareil d’enregistrement attaché au casque ou à l’ordinateur (le cas échéant).
  • Capturez l’audio (voix) et utilisez la dictée pour la stocker en tant que chaîne.
  • Une fois la voix suspendue, soumettez la dictée à la classe LuisManager .

Pour créer cette classe :

  1. Cliquez avec le bouton droit dans le volet Project, Créer un > dossier. Appelez les scripts du dossier.

    Create Scripts folder.

  2. Avec le dossier Scripts créé, double-cliquez dessus pour l’ouvrir. Ensuite, dans ce dossier, cliquez avec le bouton droit sur Créer un > script C#. Nommez le script MicrophoneManager.

  3. Double-cliquez sur MicrophoneManager pour l’ouvrir avec Visual Studio.

  4. Ajoutez les espaces de noms suivants en haut du fichier :

        using UnityEngine;
        using UnityEngine.Windows.Speech;
    
  5. Ajoutez ensuite les variables suivantes à l’intérieur de la classe 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. Les méthodes Eveil() et Start() doivent maintenant être ajoutées. Celles-ci seront appelées lorsque la classe initialise :

        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. Vous avez maintenant besoin de la méthode que l’application utilise pour démarrer et arrêter la capture vocale, et la transmettre à la classe LuisManager , que vous allez générer bientôt.

        /// <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. Ajoutez un gestionnaire de dictée qui sera appelé lorsque la voix s’interrompt. Cette méthode transmet le texte de dictée à la classe 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);
        }
    

    Important

    Supprimez la méthode Update() car cette classe ne l’utilisera pas.

  9. Veillez à enregistrer vos modifications dans Visual Studio avant de revenir à Unity.

    Notes

    À ce stade, vous remarquerez une erreur qui s’affiche dans le panneau console de l’éditeur Unity. Cela est dû au fait que le code fait référence à la classe LuisManager que vous allez créer dans le chapitre suivant.

Chapitre 6 : Créer la classe LUISManager

Il est temps de créer la classe LuisManager , qui effectuera l’appel au service Azure LUIS.

L’objectif de cette classe est de recevoir le texte de dictée de la classe MicrophoneManager et de l’envoyer à l’API Azure Language Understanding à analyser.

Cette classe désérialise la réponse JSON et appelle les méthodes appropriées de la classe Comportement pour déclencher une action.

Pour créer cette classe :

  1. Double-cliquez sur le dossier Scripts pour l’ouvrir.

  2. Cliquez avec le bouton droit dans le dossier Scripts , cliquez sur Créer un > script C#. Nommez le script LuisManager.

  3. Double-cliquez sur le script pour l’ouvrir avec Visual Studio.

  4. Ajoutez les espaces de noms suivants en haut du fichier :

        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. Vous allez commencer par créer trois classes à l’intérieur de la classe LuisManager (dans le même fichier de script, au-dessus de la méthode Start() qui représente la réponse JSON désérialisée à partir d’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. Ensuite, ajoutez les variables suivantes à l’intérieur de la classe 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. Veillez à placer votre point de terminaison LUIS maintenant (que vous aurez à partir de votre portail LUIS).

  8. Le code de la méthode Awake() doit maintenant être ajouté. Cette méthode est appelée lorsque la classe initialise :

        private void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  9. Vous avez maintenant besoin des méthodes que cette application utilise pour envoyer la dictée reçue de la classe MicrophoneManager à LUIS, puis recevoir et désérialiser la réponse.

  10. Une fois que la valeur de l’intention et des entités associées a été déterminée, elles sont transmises à l’instance de la classe Comportements pour déclencher l’action prévue.

        /// <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. Créez une méthode appelée AnalyseResponseElements() qui lit l’AnalyseQuery obtenue et détermine les entités. Une fois ces entités déterminées, elles seront transmises à l’instance de la classe Comportements à utiliser dans les actions.

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

    Important

    Supprimez les méthodes Start() et Update(), car cette classe ne les utilisera pas.

  12. Veillez à enregistrer vos modifications dans Visual Studio avant de revenir à Unity.

Notes

À ce stade, vous remarquerez plusieurs erreurs qui apparaissent dans le panneau console de l’éditeur Unity. Cela est dû au fait que le code fait référence à la classe Comportement que vous allez créer dans le chapitre suivant.

Chapitre 7 : Créer la classe Comportements

La classe Behaviours déclenche les actions à l’aide des entités fournies par la classe LuisManager .

Pour créer cette classe :

  1. Double-cliquez sur le dossier Scripts pour l’ouvrir.

  2. Cliquez avec le bouton droit dans le dossier Scripts , cliquez sur Créer un > script C#. Nommez les comportements de script.

  3. Double-cliquez sur le script pour l’ouvrir avec Visual Studio.

  4. Ajoutez ensuite les variables suivantes à l’intérieur de la classe Comportement :

        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. Ajoutez le code de méthode Awake(). Cette méthode est appelée lorsque la classe initialise :

        void Awake()
        {
            // allows this class instance to behave like a singleton
            instance = this;
        }
    
  6. Les méthodes suivantes sont appelées par la classe LuisManager (que vous avez créée précédemment) pour déterminer quel objet est la cible de la requête, puis déclencher l’action appropriée.

        /// <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. Ajoutez la méthode FindTarget() pour déterminer lequel des GameObjects est la cible de l’intention actuelle. Cette méthode définit la cible par défaut sur GameObject en tant que « gazed » si aucune cible explicite n’est définie dans les entités.

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

    Important

    Supprimez les méthodes Start() et Update(), car cette classe ne les utilisera pas.

  8. Veillez à enregistrer vos modifications dans Visual Studio avant de revenir à Unity.

Chapitre 8 : Créer la classe de regard

La dernière classe dont vous aurez besoin pour terminer cette application est la classe Regarde . Cette classe met à jour la référence à GameObject actuellement dans le focus visuel de l’utilisateur.

Pour créer cette classe :

  1. Double-cliquez sur le dossier Scripts pour l’ouvrir.

  2. Cliquez avec le bouton droit dans le dossier Scripts , cliquez sur Créer un > script C#. Nommez le regard de script.

  3. Double-cliquez sur le script pour l’ouvrir avec Visual Studio.

  4. Insérez le code suivant pour cette classe :

        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. Veillez à enregistrer vos modifications dans Visual Studio avant de revenir à Unity.

Chapitre 9 : Achèvement de la configuration de la scène

  1. Pour terminer la configuration de la scène, faites glisser chaque script que vous avez créé à partir du dossier scripts vers l’objet appareil photo principal dans le panneau hiérarchie.

  2. Sélectionnez la caméra principale et examinez le panneau inspecteur, vous devez pouvoir voir chaque script que vous avez attaché, et vous remarquerez qu’il existe des paramètres sur chaque script qui n’est pas encore défini.

    Setting the Camera Reference Targets.

  3. Pour définir correctement ces paramètres, suivez ces instructions :

    1. MicrophoneManager :

      • À partir du panneau hiérarchie, faites glisser l’objet Texte de dictée dans la zone de valeur du paramètre de texte de dictée .
    2. Comportements, à partir du panneau Hiérarchie :

      • Faites glisser l’objet Sphere dans la zone cible de référence Sphere .
      • Faites glisser le cylindre dans la zone cible de référence du cylindre .
      • Faites glisser le cube dans la zone cible de référence du cube .
    3. Regardez :

      • Définissez la distance maximale du regard sur 300 (si ce n’est pas déjà le cas).
  4. Le résultat doit ressembler à l’image ci-dessous :

    Showing the Camera Reference Targets, now set.

Chapitre 10 – Tester dans l’éditeur Unity

Testez que le programme d’installation de scène est correctement implémenté.

Assurez-vous que :

  • Tous les scripts sont attachés à l’objet Main Camera .
  • Tous les champs du Panneau d’inspecteur de caméra principal sont attribués correctement.
  1. Appuyez sur le bouton Lecture dans l’Éditeur Unity. L’application doit s’exécuter dans le casque immersif attaché.

  2. Essayez quelques énoncés, tels que :

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

    Notes

    Si vous voyez une erreur dans la console Unity sur la modification par défaut de l’appareil audio, la scène peut ne pas fonctionner comme prévu. Cela est dû à la façon dont le portail de réalité mixte traite des microphones intégrés pour les casques qui les ont. Si vous voyez cette erreur, arrêtez simplement la scène et démarrez-la de nouveau et les choses doivent fonctionner comme prévu.

Chapitre 11 : Générer et charger la solution UWP

Une fois que vous avez vérifié que l’application fonctionne dans l’Éditeur Unity, vous êtes prêt à créer et déployer.

Pour générer :

  1. Enregistrez la scène actuelle en cliquant sur Enregistrer le fichier>.

  2. Accédez à la Paramètres de build de fichiers>.

  3. Cochez la case appelée Projets Unity C# (utile pour voir et déboguer votre code une fois le projet UWP créé.

  4. Cliquez sur Ajouter des scènes d’ouverture, puis cliquez sur Générer.

    Build Settings window

  5. Vous êtes invité à sélectionner le dossier dans lequel vous souhaitez générer la solution.

  6. Créez un dossier BUILDS et, dans ce dossier, créez un autre dossier avec un nom approprié de votre choix.

  7. Cliquez sur Sélectionner un dossier pour commencer la build à cet emplacement.

    Create Builds FolderSelect Builds Folder

  8. Une fois que Unity a terminé la génération (cela peut prendre un certain temps), elle doit ouvrir une fenêtre Explorateur de fichiers à l’emplacement de votre build.

Pour déployer sur un ordinateur local :

  1. Dans Visual Studio, ouvrez le fichier de solution créé dans le chapitre précédent.

  2. Dans la plateforme de solutions, sélectionnez x86, Ordinateur local.

  3. Dans la configuration de la solution , sélectionnez Déboguer.

    Pour le Microsoft HoloLens, vous pouvez trouver plus facile de définir cette option sur l’ordinateur distant afin que vous ne soyez pas attachés à votre ordinateur. Toutefois, vous devez également effectuer les opérations suivantes :

    • Connaissez l’adresse IP de votre HoloLens, qui se trouve dans l’Paramètres > Internet réseau &> Wi-Fi > options avancées ; l’adresse IPv4 est l’adresse que vous devez utiliser.
    • Vérifiez que le mode développeur est activé ; trouvé dans Paramètres > Update & Security > for developers.

    Deploy App

  4. Accédez au menu Build , puis cliquez sur Déployer la solution pour charger l’application sur votre ordinateur.

  5. Votre application doit maintenant apparaître dans la liste des applications installées, prête à être lancée !

  6. Une fois lancée, l’application vous invite à autoriser l’accès au microphone. Utilisez les contrôleurs de mouvement ou l’entrée vocale ou le clavier pour appuyer sur le bouton OUI .

Chapitre 12 : Amélioration de votre service LUIS

Important

Ce chapitre est incroyablement important et doit être itéré plusieurs fois, car il aidera à améliorer la précision de votre service LUIS : assurez-vous de le terminer.

Pour améliorer le niveau de compréhension fourni par LUIS, vous devez capturer de nouveaux énoncés et les utiliser pour réinscrire votre application LUIS.

Par exemple, vous avez peut-être formé LUIS pour comprendre « Augmenter » et « Upsize », mais ne souhaitez-vous pas que votre application comprenne également les mots comme « Agrandir » ?

Une fois que vous avez utilisé votre application quelques fois, tout ce que vous avez dit sera collecté par LUIS et disponible dans le PORTAIL LUIS.

  1. Accédez à votre application portail en suivant ce LIEN et connectez-vous.

  2. Une fois connecté avec vos informations d’identification MS, cliquez sur le nom de votre application.

  3. Cliquez sur le bouton Vérifier les énoncés de point de terminaison à gauche de la page.

    Review Utterances

  4. Vous serez affiché une liste des énoncés qui ont été envoyés à LUIS par votre application de réalité mixte.

    List of Utterances

Vous remarquerez quelques entités mises en surbrillance.

En pointant sur chaque mot mis en surbrillance, vous pouvez passer en revue chaque énoncé et déterminer quelle entité a été reconnue correctement, quelles entités sont incorrectes et quelles entités sont manquées.

Dans l’exemple ci-dessus, il a été constaté que le mot « lance » avait été mis en surbrillance comme cible, afin de corriger l’erreur, ce qui est fait en pointant sur le mot avec la souris et en cliquant sur Supprimer l’étiquette.

Check utterancesRemove Label Image

  1. Si vous trouvez des énoncés complètement incorrects, vous pouvez les supprimer à l’aide du bouton Supprimer sur le côté droit de l’écran.

    Delete wrong utterances

  2. Ou si vous sentez que LUIS a interprété correctement l’énoncé, vous pouvez valider sa compréhension à l’aide du bouton Ajouter à l’intention alignée .

    Add to aligned intent

  3. Une fois que vous avez trié tous les énoncés affichés, essayez de recharger la page pour voir si d’autres éléments sont disponibles.

  4. Il est très important de répéter ce processus autant de fois que possible pour améliorer la compréhension de votre application.

En avant !

Votre application intégrée LUIS terminée

Félicitations, vous avez créé une application de réalité mixte qui tire parti d’Azure Language Understanding Intelligence Service, pour comprendre ce qu’un utilisateur dit et agir sur ces informations.

Lab outcome

Exercices bonus

Exercice 1

Lors de l’utilisation de cette application, vous pouvez remarquer que si vous regardez l’objet Floor et que vous demandez de modifier sa couleur, elle le fera. Pouvez-vous savoir comment empêcher votre application de modifier la couleur de plancher ?

Exercice 2

Essayez d’étendre les fonctionnalités LUIS et App, en ajoutant des fonctionnalités supplémentaires pour les objets dans la scène; par exemple, créez de nouveaux objets au point d’accès de regard, en fonction de ce que l’utilisateur dit, puis de pouvoir utiliser ces objets en même temps que les objets de scène actuels, avec les commandes existantes.