HoloLens (prima generazione) e Azure 303: Comprensione del linguaggio naturale (LUIS)
Nota
Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati. Ci sarà una nuova serie di esercitazioni che verranno pubblicate in futuro che dimostreranno come sviluppare per HoloLens 2. Questo avviso verrà aggiornato con un collegamento a tali esercitazioni quando vengono pubblicate.
In questo corso si apprenderà come integrare Language Understanding in un'applicazione di realtà mista usando Servizi cognitivi di Azure, con l'API Language Understanding.
Language Understanding (LUIS) è un servizio di Microsoft Azure, che offre alle applicazioni la possibilità di ottenere significato dall'input dell'utente, ad esempio tramite l'estrazione di ciò che una persona potrebbe volere, nelle proprie parole. Questo risultato viene ottenuto tramite Machine Learning, che comprende e apprende le informazioni di input e può quindi rispondere con informazioni dettagliate, pertinenti e pertinenti. Per altre informazioni, visitare la pagina Luis (Azure Language Understanding).
Dopo aver completato questo corso, si avrà un'applicazione visore VR immersive di realtà mista che sarà in grado di eseguire le operazioni seguenti:
- Acquisire la voce di input dell'utente, usando il microfono collegato al visore VR immersive.
- Inviare la dettatura acquisita di Azure Language Understanding Intelligent Service (LUIS).
- Chiedere a LUIS di estrarre significato dalle informazioni di invio, che verranno analizzate e tentare di determinare la finalità della richiesta dell'utente.
Lo sviluppo includerà la creazione di un'app in cui l'utente potrà usare la voce e/o lo sguardo fisso per modificare le dimensioni e il colore degli oggetti nella scena. L'uso dei controller di movimento non verrà coperto.
Nell'applicazione spetta all'utente come integrare i risultati con la progettazione. Questo corso è progettato per illustrare come integrare un servizio di Azure con il progetto Unity. È il tuo compito usare le conoscenze acquisite da questo corso per migliorare l'applicazione di realtà mista.
Prepararsi a eseguire il training di LUIS più volte, che è trattato nel capitolo 12. Si otterranno risultati migliori più volte è stato eseguito il training di LUIS.
Supporto di dispositivi
| Corso | HoloLens | Visori VR immersive |
|---|---|---|
| MR e Azure 303: Luis (Natural Language Understanding) | ✔️ | ✔️ |
Nota
Anche se questo corso è incentrato principalmente sui visori VR immersive di Windows Realtà mista, puoi anche applicare ciò che impari in questo corso a Microsoft HoloLens. Mentre segui il corso, vedrai le note su eventuali modifiche che potresti dover usare per supportare HoloLens. Quando si usa HoloLens, è possibile notare un'eco durante l'acquisizione vocale.
Prerequisiti
Nota
Questa esercitazione è progettata per gli sviluppatori che hanno esperienza di base con Unity e C#. Tenere presente anche che i prerequisiti e le istruzioni scritte all'interno di questo documento rappresentano ciò che è stato testato e verificato al momento della scrittura (maggio 2018). Sei libero di usare il software più recente, come elencato all'interno dell'articolo installare gli strumenti , anche se non si deve presumere che le informazioni in questo corso corrispondano perfettamente a ciò che troverai nel software più recente rispetto a quello elencato di seguito.
Per questo corso è consigliabile usare l'hardware e il software seguenti:
- Un PC di sviluppo, compatibile con Windows Realtà mista per lo sviluppo di visori VR immersive
- Windows 10 Fall Creators Update (o versione successiva) con la modalità sviluppatore abilitata
- La versione più recente di Windows 10 SDK
- Unity 2017.4
- Visual Studio 2017
- Visore VR immersive di Windows Realtà mista o Microsoft HoloLens con la modalità sviluppatore abilitata
- Un set di cuffie con un microfono incorporato (se l'auricolare non ha un microfono e altoparlanti incorporati)
- Accesso a Internet per la configurazione di Azure e il recupero LUIS
Prima di iniziare
Per evitare di riscontrare problemi durante la compilazione di questo progetto, è consigliabile creare il progetto menzionato in questa esercitazione in una cartella radice o quasi radice (i percorsi delle cartelle lunghe possono causare problemi in fase di compilazione).
Per consentire al computer di abilitare la dettatura, passare a Impostazioni > di Windows Riconoscimento vocale privacy > , Input penna e digitazione e premere sul pulsante Attiva servizi vocali e suggerimenti di digitazione.
Il codice in questa esercitazione consentirà di registrare dal dispositivo microfono predefinito impostato nel computer. Assicurarsi che il dispositivo microfono predefinito sia impostato come quello che si vuole usare per acquisire la voce.
Se il visore VR ha un microfono incorporato, assicurati che l'opzione "Quando indosso il visore VR, passa al microfono visore" sia attivata nelle impostazioni del portale di Realtà mista.
Capitolo 1: Configurare il portale di Azure
Per usare il servizio Language Understanding in Azure, è necessario configurare un'istanza del servizio da rendere disponibile per l'applicazione.
Accedere al portale di Azure.
Nota
Se non si ha già un account Azure, è necessario crearne uno. Se si segue questa esercitazione in una classe o in una situazione di laboratorio, chiedere all'insegnante o a uno dei prottori di assistenza per configurare il nuovo account.
Dopo aver eseguito l'accesso, fare clic su Nuovo nell'angolo superiore sinistro e cercare Language Understanding e fare clic su INVIO.
Nota
La parola New potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.
La nuova pagina a destra fornirà una descrizione del servizio Language Understanding. Nella parte inferiore sinistra di questa pagina selezionare il pulsante Crea per creare un'istanza del servizio.
Dopo aver fatto clic su Crea:
Inserire il nome desiderato per questa istanza del servizio.
Selezionare una Sottoscrizione.
Selezionare il piano tariffario appropriato per l'utente, se è la prima volta che si crea un servizio LUIS, sarà disponibile un livello gratuito (denominato F0). L'allocazione gratuita deve essere più che sufficiente per questo corso.
Scegliere un gruppo di risorse o crearne uno nuovo. Un gruppo di risorse consente di monitorare, controllare l'accesso, effettuare il provisioning e gestire la fatturazione per una raccolta di asset di Azure. È consigliabile mantenere tutti i servizi di Azure associati a un singolo progetto (ad esempio, questi corsi) in un gruppo di risorse comune.
Per altre informazioni sui gruppi di risorse di Azure, vedere l'articolo relativo al gruppo di risorse.
Determinare la località per il gruppo di risorse (se si sta creando un nuovo gruppo di risorse). La posizione si trova idealmente nell'area in cui verrà eseguita l'applicazione. Alcuni asset di Azure sono disponibili solo in determinate aree.
Sarà anche necessario verificare di aver compreso le condizioni e le condizioni applicate al servizio.
Seleziona Crea.
Dopo aver fatto clic su Crea, è necessario attendere che il servizio venga creato, l'operazione potrebbe richiedere un minuto.
Una notifica verrà visualizzata nel portale dopo la creazione dell'istanza del servizio.
Fare clic sulla notifica per esplorare la nuova istanza del servizio.
Fare clic sul pulsante Vai alla risorsa nella notifica per esplorare la nuova istanza del servizio. Verrà visualizzata la nuova istanza del servizio LUIS.
In questa esercitazione, l'applicazione dovrà effettuare chiamate al servizio, che viene eseguita usando la chiave di sottoscrizione del servizio.
Nella pagina Avvio rapido del servizio API LUIS passare al primo passaggio, Afferrare le chiavi e fare clic su Chiavi. È anche possibile fare clic sul collegamento ipertestuale blu Chiavi, che si trova nel menu di spostamento dei servizi, indicato dall'icona della chiave. Verranno visualizzate le chiavi del servizio.
Prendere una copia di una delle chiavi visualizzate, perché sarà necessario più avanti nel progetto.
Nella pagina Servizio fare clic su Language Understanding Portal per essere reindirizzati alla pagina Web che verrà usata per creare il nuovo servizio all'interno dell'app LUIS.
Capitolo 2: Portale di Language Understanding
In questa sezione si apprenderà come creare un'app LUIS nel portale LUIS.
Importante
Tenere presente che la configurazione delle entità, delle finalità e delle espressioni all'interno di questo capitolo è solo il primo passaggio per la creazione del servizio LUIS: è anche necessario ripetere il training del servizio, più volte, per renderlo più accurato. La ripetizione del training del servizio è descritta nell'ultimo capitolo di questo corso, quindi assicurarsi di completarla.
Quando si raggiunge il portale di Language Understanding, potrebbe essere necessario eseguire l'accesso, se non si è già, con le stesse credenziali del portale di Azure.
Se è la prima volta che si usa LUIS, è necessario scorrere verso il basso fino alla fine della pagina iniziale per trovare e fare clic sul pulsante Crea app LUIS.
Dopo aver eseguito l'accesso, fare clic su App personali (se non si è in quella sezione attualmente). È quindi possibile fare clic su Crea nuova app.
Assegnare all'app un nome.
Se l'app deve comprendere una lingua diversa dall'inglese, devi modificare le impostazioni cultura in base alla lingua appropriata.
Qui è anche possibile aggiungere una descrizione della nuova app LUIS.
Dopo aver premuto Fine, si immetterà la pagina Compila della nuova applicazione LUIS.
Ecco alcuni concetti importanti da comprendere:
- Finalità, rappresenta il metodo che verrà chiamato dopo una query dall'utente. Una FINALITÀ può avere una o più ENTITÀ.
- Entity, è un componente della query che descrive le informazioni rilevanti per la finalità.
- Le espressioni sono esempi di query fornite dallo sviluppatore, che LUIS userà per eseguire il training.
Se questi concetti non sono perfettamente chiari, non preoccuparti, come questo corso li chiarirà ulteriormente in questo capitolo.
Si inizierà creando le entità necessarie per creare questo corso.
Sul lato sinistro della pagina fare clic su Entità e quindi su Crea nuova entità.
Chiamare il nuovo colore dell'entità, impostarne il tipo su Semplice, quindi premere Fine.
Ripetere questo processo per creare tre (3) più entità semplici denominate:
- upsize
- ridimensionare
- target
Il risultato dovrebbe essere simile all'immagine seguente:
A questo punto è possibile iniziare a creare finalità.
Avviso
Non eliminare la finalità Nessuno .
Sul lato sinistro della pagina fare clic su Intents (Finalità) e quindi su Create new intent (Crea nuova finalità).
Chiamare la nuova proprietà ChangeObjectColor.
Importante
Questo nome di finalità viene usato nel codice più avanti in questo corso, quindi per ottenere risultati ottimali, usare questo nome esattamente come specificato.
Dopo aver confermato il nome, si verrà indirizzati alla pagina Finalità.
Si noterà che è presente una casella di testo che chiede di digitare 5 o più espressioni diverse.
Nota
LUIS converte tutte le espressioni in lettere minuscole.
- Inserire l'espressione seguente nella casella di testo superiore (attualmente con il testo Digitare circa 5 esempi... ) e premere INVIO:
The color of the cylinder must be red
Si noterà che la nuova espressione verrà visualizzata in un elenco sottostante.
Seguendo lo stesso processo, inserire le sei (6) espressioni seguenti:
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
Per ogni espressione creata, è necessario identificare le parole da usare da LUIS come entità. In questo esempio è necessario etichettare tutti i colori come entità colore e tutti i possibili riferimenti a una destinazione come entità di destinazione .
A tale scopo, provare a fare clic sul cilindro della parola nella prima espressione e selezionare la destinazione.
Fare clic sulla parola rossa nella prima espressione e selezionare il colore.
Etichettare anche la riga successiva, dove il cubo deve essere una destinazione e il nero deve essere un colore. Si noti anche l'uso delle parole 'this', 'it' e 'this object', che stiamo fornendo, in modo da avere tipi di destinazione non specifici disponibili anche.
Ripetere il processo precedente fino a quando tutte le espressioni non hanno l'etichetta Entities ( Entità). Per assistenza, vedere l'immagine seguente.
Suggerimento
Quando si selezionano le parole da etichettare come entità:
- Per le singole parole è sufficiente fare clic su di essi.
- Per un set di due o più parole, fare clic all'inizio e quindi alla fine del set.
Nota
È possibile usare il pulsante Attiva /Disattiva visualizzazione token per passare da entità a token/visualizzazione token.
I risultati devono essere visualizzati nelle immagini seguenti, che mostra la visualizzazione Entità/Token:
A questo punto premere il pulsante Train (Esegui training) in alto a destra della pagina e attendere che l'indicatore rotondo piccolo su di esso sia verde. Ciò indica che LUIS è stato sottoposto a training correttamente per riconoscere questa finalità.
Come esercizio, creare una nuova finalità denominata ChangeObjectSize usando la destinazione Entities, upsize e downsize.
Seguendo lo stesso processo della finalità precedente, inserire le otto (8) espressioni seguenti per modifica dimensioni :
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 objectIl risultato dovrebbe essere simile a quello nell'immagine seguente:
Dopo aver creato e sottoposto a training entrambe le finalità, ChangeObjectColor e ChangeObjectSize, fare clic sul pulsante PUBBLICA nella parte superiore della pagina.
Nella pagina Pubblica si finalizzerà e si pubblicherà l'app LUIS in modo che sia accessibile dal codice.
Impostare l'elenco a discesa Pubblica su come produzione.
Impostare fuso orario sul fuso orario.
Selezionare la casella Includi tutti i punteggi delle finalità stimati.
Fare clic su Pubblica nello slot di produzione.
Nella sezione Risorse e chiavi:
- Selezionare l'area impostata per l'istanza del servizio nel portale di Azure.
- Si noterà un elemento Starter_Key di seguito, ignorarlo.
- Fare clic su Aggiungi chiave e inserire la chiave ottenuta nel portale di Azure al momento della creazione dell'istanza del servizio. Se Azure e il portale LUIS sono connessi allo stesso utente, verranno forniti menu a discesa per Nome tenant, Nome sottoscrizione e Chiave da usare (avrà lo stesso nome fornito in precedenza nel portale di Azure).
Importante
Sotto Endpoint, eseguire una copia dell'endpoint corrispondente alla chiave inserita, verrà presto usata nel codice.
Capitolo 3: Configurare il progetto Unity
Di seguito è riportata una configurazione tipica per lo sviluppo con la realtà mista e, di conseguenza, è un modello valido per altri progetti.
Aprire Unity e fare clic su Nuovo.
Sarà ora necessario specificare un nome di progetto Unity, inserire MR_LUIS. Assicurarsi che il tipo di progetto sia impostato su 3D. Impostare La posizione su un punto appropriato per l'utente (tenere presente che più vicino alle directory radice è preferibile). Fare quindi clic su Crea progetto.
Con Unity aperto, vale la pena verificare che l'editor di script predefinito sia impostato su Visual Studio. Passare a Modifica > preferenze e quindi dalla nuova finestra passare a Strumenti esterni. Modificare l'editor di script esterni in Visual Studio 2017. Chiudere la finestra Preferenze .
Passare quindi a Impostazioni compilazione file > e impostare la piattaforma su piattaforma UWP (Universal Windows Platform), facendo clic sul pulsante Cambia piattaforma.
Passare a Impostazioni di compilazione file > e assicurarsi che:
Il dispositivo di destinazione è impostato su Qualsiasi dispositivo
Per Microsoft HoloLens impostare Dispositivo di destinazione su HoloLens.
Il tipo di compilazione è impostato su D3D
L'SDK è impostato su Latest installed (Versione più recente installata)
La versione di Visual Studio è impostata su Versione più recente installata
Compilazione ed esecuzione è impostata su Computer locale
Salvare la scena e aggiungerla alla compilazione.
A tale scopo, selezionare Aggiungi scene aperte. Verrà visualizzata una finestra di salvataggio.
Creare una nuova cartella per questa cartella e qualsiasi scena futura, quindi selezionare il pulsante Nuova cartella per creare una nuova cartella, denominarla Scene.
Aprire la cartella Scenes appena creata e quindi nel campo Nome file: digitare MR_LuisScene, quindi premere Salva.
Le impostazioni rimanenti, in Impostazioni di compilazione, devono essere lasciate come predefinite per il momento.
Nella finestra Impostazioni di compilazione fare clic sul pulsante Impostazioni lettore per aprire il pannello correlato nello spazio in cui si trova il controllo.
In questo pannello è necessario verificare alcune impostazioni:
Nella scheda Altre impostazioni :
La versione del runtime di scripting deve essere stabile (equivalente a .NET 3.5).
Il back-end di scripting deve essere .NET
Il livello di compatibilità api deve essere .NET 4.6
Nella scheda Impostazioni di pubblicazione, in Funzionalità selezionare:
InternetClient
Microfono
Più avanti nel pannello, in Impostazioni XR (disponibili sotto Impostazioni di pubblicazione), selezionare Realtà virtuale supportata, assicurarsi che Windows Realtà mista SDK sia stato aggiunto.
Tornare in Build Settings Unity C# Projects (Impostazioni di compilazione) I progetti C# non sono più disattivati. Selezionare la casella di controllo accanto a questa opzione.
Chiudere la finestra Build Settings (Impostazioni di compilazione).
Salvare la scena e il progetto (FILE > SAVE SCENE/FILE > SAVE PROJECT).
Capitolo 4 : Creare la scena
Importante
Se si vuole ignorare il componente Di configurazione di Unity di questo corso e continuare direttamente nel codice, è possibile scaricare questo pacchetto unitypackage, importarlo nel progetto come pacchetto personalizzato e quindi continuare dal capitolo 5.
Fare clic con il pulsante destro del mouse in un'area vuota del pannello gerarchia, in Oggetto 3D, aggiungere un piano.
Tenere presente che quando si fa di nuovo clic con il pulsante destro del mouse all'interno della gerarchia per creare altri oggetti, se è ancora selezionato l'ultimo oggetto, l'oggetto selezionato sarà l'elemento padre del nuovo oggetto. Evitare questo clic con il pulsante sinistro del mouse in uno spazio vuoto all'interno della gerarchia e quindi fare clic con il pulsante destro del mouse.
Ripetere la procedura precedente per aggiungere gli oggetti seguenti:
- Sfera
- Cilindro
- Cube
- Testo 3D
La gerarchia della scena risultante dovrebbe essere simile a quella nell'immagine seguente:
Fare clic con il pulsante sinistro del mouse sulla fotocamera principale per selezionarla, guardare il Pannello di controllo per visualizzare l'oggetto Camera con tutti i relativi componenti.
Fare clic sul pulsante Aggiungi componente nella parte inferiore del Pannello di controllo.
Cercare il componente denominato Origine audio, come illustrato in precedenza.
Assicurarsi inoltre che il componente Trasforma della fotocamera principale sia impostato su (0,0,0), questa operazione può essere eseguita premendo l'icona a forma di ingranaggio accanto al componente Trasformazione della fotocamera e selezionando Reimposta. Il componente Transform dovrebbe quindi essere simile al seguente:
- La posizione è impostata su 0, 0, 0.
- La rotazione è impostata su 0, 0, 0.
Nota
Per Microsoft HoloLens, dovrai anche modificare quanto segue, che fanno parte del componente Fotocamera, che si trova nella fotocamera principale:
- Cancella flag: colore a tinta unita.
- Sfondo 'Nero, Alfa 0' - Colore esadecimale: #00000000.
Fare clic con il pulsante sinistro del mouse sul piano per selezionarlo. Nel Pannello di controllo impostare il componente Transform con i valori seguenti:
Asse X Asse Y Asse Z 0 -1 0 Fare clic con il pulsante sinistro del mouse sulla sfera per selezionarla. Nel Pannello di controllo impostare il componente Transform con i valori seguenti:
Asse X Asse Y Asse Z 2 1 2 Fare clic con il pulsante sinistro del mouse sul cilindro per selezionarlo. Nel Pannello di controllo impostare il componente Transform con i valori seguenti:
Asse X Asse Y Asse Z -2 1 2 Fare clic con il pulsante sinistro del mouse sul cubo per selezionarlo. Nel Pannello di controllo impostare il componente Transform con i valori seguenti:
Trasforma - Posizione
| X | Y | Z |
|---|---|---|
| 0 | 1 | 4 |
Trasforma - Rotazione
| X | Y | Z |
|---|---|---|
| 45 | 45 | 0 |
- Fare clic con il pulsante sinistro del mouse sull'oggetto Nuovo testo per selezionarlo. Nel Pannello di controllo impostare il componente Transform con i valori seguenti:
Trasforma - Posizione
| X | Y | Z |
|---|---|---|
| -2 | 6 | 9 |
Trasforma - Ridimensionamento
| X | Y | Z |
|---|---|---|
| 0,1 | 0,1 | 0,1 |
Impostare Dimensione carattere nel componente Mesh di testo su 50.
Modificare il nome dell'oggetto Text Mesh in Testo dettatura.
La struttura Del pannello gerarchia avrà ora un aspetto simile al seguente:
La scena finale sarà simile all'immagine seguente:
Capitolo 5: Creare la classe MicrophoneManager
Il primo script che si intende creare è la classe MicrophoneManager . A questo scopo, si creerà LuisManager, la classe Behaviors e infine la classe Gaze (è possibile creare tutti questi elementi ora, anche se verrà trattato come si raggiunge ogni capitolo).
La classe MicrophoneManager è responsabile di:
- Rilevamento del dispositivo di registrazione collegato al visore VR o al computer (a seconda del valore predefinito).
- Acquisire l'audio (voce) e usare la dettatura per archiviarla come stringa.
- Una volta sospesa la voce, inviare la dettatura alla classe LuisManager .
Per creare questa classe:
Fare clic con il pulsante destro del mouse nel pannello del progetto, Crea > cartella. Chiamare la cartella Scripts.
Dopo che la cartella Scripts è stata creata, fare doppio clic su di essa per aprirla. Quindi, all'interno di tale cartella, fare clic con il pulsante destro del mouse su Crea > script C#. Assegnare allo script il nome MicrophoneManager.
Fare doppio clic su MicrophoneManager per aprirlo con Visual Studio.
Aggiungere gli spazi dei nomi seguenti all'inizio del file:
using UnityEngine; using UnityEngine.Windows.Speech;Aggiungere quindi le variabili seguenti all'interno della 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È ora necessario aggiungere il codice per i metodi Awake() e Start(). Questi verranno chiamati quando la classe inizializza:
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"); } }A questo punto è necessario il metodo usato dall'app per avviare e arrestare l'acquisizione vocale e passarlo alla classe LuisManager , che verrà compilata a breve.
/// <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..."); }Aggiungere un gestore di dettatura che verrà richiamato quando la voce viene sospesa. Questo metodo passerà il testo della dettatura alla 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); }Importante
Eliminare il metodo Update() perché questa classe non lo userà.
Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Nota
A questo punto si noterà un errore visualizzato nel pannello della console dell'editor di Unity. Questo perché il codice fa riferimento alla classe LuisManager che verrà creata nel capitolo successivo.
Capitolo 6: Creare la classe LUISManager
È il momento di creare la classe LuisManager , che eseguirà la chiamata al servizio LUIS di Azure.
Lo scopo di questa classe è ricevere il testo di dettatura dalla classe MicrophoneManager e inviarlo all'API Azure Language Understanding da analizzare.
Questa classe deserializzerà la risposta JSON e chiamerà i metodi appropriati della classe Behaviors per attivare un'azione.
Per creare questa classe:
Fare doppio clic sulla cartella Scripts per aprirla.
Fare clic con il pulsante destro del mouse all'interno della cartella Scripts e scegliere Crea > script C#. Assegnare allo script il nome LuisManager.
Fare doppio clic sullo script per aprirlo con Visual Studio.
Aggiungere gli spazi dei nomi seguenti all'inizio del file:
using System; using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using UnityEngine.Networking;Si inizierà creando tre classi all'interno della classe LuisManager (all'interno dello stesso file di script, sopra il metodo Start() che rappresenterà la risposta JSON deserializzata da 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; }Aggiungere quindi le variabili seguenti all'interno della 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";Assicurarsi di posizionare l'endpoint LUIS in ora (che sarà disponibile dal portale LUIS).
È ora necessario aggiungere il codice per il metodo Awake(). Questo metodo verrà chiamato quando la classe inizializza:
private void Awake() { // allows this class instance to behave like a singleton instance = this; }A questo punto sono necessari i metodi usati da questa applicazione per inviare la dettatura ricevuta dalla classe MicrophoneManager a LUIS e quindi ricevere e deserializzare la risposta.
Dopo aver determinato il valore della finalità e delle entità associate, vengono passati all'istanza della classe Behaviors per attivare l'azione desiderata.
/// <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; } }Creare un nuovo metodo denominato AnalyseResponseElements() che leggerà il risultato di AnalyzerdQuery e determinerà le entità. Dopo aver determinato tali entità, verranno passate all'istanza della classe Behaviors da usare nelle azioni.
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; } }Importante
Eliminare i metodi Start() e Update() perché questa classe non li userà.
Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Nota
A questo punto si noteranno diversi errori visualizzati nel pannello della console dell'editor di Unity. Questo perché il codice fa riferimento alla classe Behaviors che verrà creata nel capitolo successivo.
Capitolo 7 : Creare la classe Behaviors
La classe Behaviors attiverà le azioni usando le entità fornite dalla classe LuisManager .
Per creare questa classe:
Fare doppio clic sulla cartella Scripts per aprirla.
Fare clic con il pulsante destro del mouse all'interno della cartella Scripts e scegliere Crea > script C#. Assegnare allo script il nome Comportamento.
Fare doppio clic sullo script per aprirlo con Visual Studio.
Aggiungere quindi le variabili seguenti all'interno della classe Behaviors :
public static Behaviours instance; // the following variables are references to possible targets public GameObject sphere; public GameObject cylinder; public GameObject cube; internal GameObject gazedTarget;Aggiungere il codice del metodo Awake(). Questo metodo verrà chiamato quando la classe inizializza:
void Awake() { // allows this class instance to behave like a singleton instance = this; }I metodi seguenti vengono chiamati dalla classe LuisManager (creata in precedenza) per determinare quale oggetto è la destinazione della query e quindi attivare l'azione appropriata.
/// <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); }Aggiungere il metodo FindTarget() per determinare quale dei GameObject è la destinazione della finalità corrente. Per impostazione predefinita, la destinazione viene impostata su GameObject "con sguardo fisso" se non è definita alcuna destinazione esplicita nelle entità.
/// <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; }Importante
Eliminare i metodi Start() e Update() perché questa classe non li userà.
Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Capitolo 8 : Creare la classe sguardo fisso
L'ultima classe che dovrai completare questa app è la classe Gaze . Questa classe aggiorna il riferimento al GameObject attualmente nello stato attivo dell'oggetto visivo dell'utente.
Per creare questa classe:
Fare doppio clic sulla cartella Scripts per aprirla.
Fare clic con il pulsante destro del mouse all'interno della cartella Scripts e scegliere Crea > script C#. Assegnare allo script il nome Gaze.
Fare doppio clic sullo script per aprirlo con Visual Studio.
Inserire il codice seguente per questa 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; } } }Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Capitolo 9 - Completamento della configurazione della scena
Per completare la configurazione della scena, trascinare ogni script creato dalla cartella Scripts all'oggetto Fotocamera principale nel pannello Gerarchia.
Selezionare la fotocamera principale e osservare il pannello di controllo, si dovrebbe essere in grado di visualizzare ogni script collegato e si noterà che sono presenti parametri per ogni script ancora da impostare.
Per impostare correttamente questi parametri, seguire queste istruzioni:
MicrophoneManager:
- Dal pannello Hierarchy (Gerarchia) trascinare l'oggetto Dictation Text nella casella Valore del parametro Dictation Text .
Comportamenti, nel pannello gerarchia:
- Trascinare l'oggetto Sphere nella casella di destinazione di riferimento Sphere .
- Trascinare il cilindro nella casella di destinazione del riferimento cilindro .
- Trascinare il cubo nella casella di destinazione del riferimento al cubo.
Sguardo fisso:
- Impostare La distanza massima dello sguardo fisso su 300 (se non è già).
Il risultato dovrebbe essere simile all'immagine seguente:
Capitolo 10 : Test nell'editor di Unity
Verificare che l'installazione della scena sia implementata correttamente.
Assicurarsi che:
- Tutti gli script sono collegati all'oggetto Main Camera .
- Tutti i campi nel pannello Controllo fotocamera principale vengono assegnati correttamente.
Premere il pulsante Riproduci nell'editor di Unity. L'app deve essere in esecuzione all'interno del visore VR immersive collegato.
Provare alcune espressioni, ad esempio:
make the cylinder red change the cube to yellow I want the sphere blue make this to green change it to whiteNota
Se viene visualizzato un errore nella console unity relativa alla modifica del dispositivo audio predefinito, la scena potrebbe non funzionare come previsto. Questo è dovuto al modo in cui il portale di realtà mista gestisce i microfoni predefiniti per le cuffie che li hanno. Se viene visualizzato questo errore, arrestare semplicemente la scena e avviarla di nuovo e le operazioni dovrebbero funzionare come previsto.
Capitolo 11: Compilare e trasferire localmente la soluzione UWP
Dopo aver verificato che l'applicazione funzioni nell'editor di Unity, è possibile compilare e distribuire.
Per compilare:
Salvare la scena corrente facendo clic su Salva file>.
Passare a Impostazioni di compilazione file>.
Selezionare la casella Denominata Progetti C# unity (utile per visualizzare e eseguire il debug del codice dopo la creazione del progetto UWP).
Fare clic su Aggiungi scene aperte e quindi su Compila.
Verrà richiesto di selezionare la cartella in cui si vuole compilare la soluzione.
Creare una cartella BUILD e all'interno di tale cartella creare un'altra cartella con un nome appropriato di propria scelta.
Fare clic su Seleziona cartella per avviare la compilazione in tale percorso.
Una volta completata la compilazione di Unity (potrebbe essere necessario del tempo), dovrebbe aprire una finestra Esplora file nella posizione della compilazione.
Per eseguire la distribuzione nel computer locale:
In Visual Studio aprire il file della soluzione creato nel capitolo precedente.
Nella piattaforma della soluzione selezionare x86, Computer locale.
Nella configurazione della soluzione selezionare Debug.
Per Microsoft HoloLens, potrebbe risultare più semplice impostare questa opzione su Computer remoto, in modo che non si sia collegati al computer. Tuttavia, è necessario eseguire anche le operazioni seguenti:
- Conoscere l'indirizzo IP di HoloLens, che è possibile trovare all'interno di Impostazioni > Rete e > Internet Wi-Fi > Advanced Options. IPv4 è l'indirizzo da usare.
- Assicurarsi che la modalità sviluppatore sia attivata. Disponibile in Impostazioni > Aggiornamento e sicurezza > per gli sviluppatori.
Passare al menu Compila e fare clic su Distribuisci soluzione per trasferire localmente l'applicazione nel computer.
L'app dovrebbe ora essere visualizzata nell'elenco delle app installate, pronte per l'avvio.
Dopo l'avvio, l'app chiederà di autorizzare l'accesso al microfono. Usare i controller di movimento o l'input vocale o la tastiera per premere il pulsante SÌ.
Capitolo 12 : Miglioramento del servizio LUIS
Importante
Questo capitolo è incredibilmente importante e potrebbe essere necessario eseguire l'iterazione più volte, perché contribuirà a migliorare l'accuratezza del servizio LUIS: assicurarsi di completarlo.
Per migliorare il livello di comprensione fornito da LUIS, è necessario acquisire nuove espressioni e usarle per eseguire nuovamente il training dell'app LUIS.
Ad esempio, potrebbe essere stato eseguito il training di LUIS per comprendere "Aumenta" e "Upsize", ma non si vuole che l'app comprenda anche parole come "Ingrandisci"?
Dopo aver usato l'applicazione alcune volte, tutti gli elementi che hai detto verranno raccolti da LUIS e saranno disponibili nel PORTALE LUIS.
Passare all'applicazione portale seguendo questo COLLEGAMENTO e accedere.
Dopo aver eseguito l'accesso con le credenziali MS, fare clic sul nome dell'app.
Fare clic sul pulsante Rivedi espressioni endpoint a sinistra della pagina.
Verrà visualizzato un elenco delle espressioni inviate a LUIS dall'applicazione di realtà mista.
Si noteranno alcune entità evidenziate.
Passando il puntatore del mouse su ogni parola evidenziata, è possibile esaminare ogni espressione e determinare quale entità è stata riconosciuta correttamente, quali entità sono errate e quali entità vengono perse.
Nell'esempio precedente è stato rilevato che la parola "spear" era stata evidenziata come destinazione, quindi è necessario correggere l'errore, che viene eseguito passando il puntatore del mouse sulla parola e facendo clic su Rimuovi etichetta.
Se si trovano espressioni completamente errate, è possibile eliminarle usando il pulsante Elimina a destra dello schermo.
In alternativa, se LUIS ha interpretato correttamente l'espressione, è possibile convalidarne la comprensione usando il pulsante Aggiungi a finalità allineate.
Dopo aver ordinato tutte le espressioni visualizzate, provare a ricaricare la pagina per verificare se sono disponibili altre espressioni.
È molto importante ripetere questo processo il più volte possibile per migliorare la comprensione dell'applicazione.
Buon divertimento!
Applicazione integrata LUIS completata
È stata creata un'app di realtà mista che sfrutta il servizio Intelligence di Language Understanding di Azure, per comprendere cosa dice un utente e agire su tali informazioni.
Esercizi aggiuntivi
Esercizio 1
Durante l'uso di questa applicazione è possibile notare che se si guarda l'oggetto Floor e si chiede di modificarne il colore, lo farà. È possibile determinare come impedire all'applicazione di modificare il colore floor?
Esercizio 2
Provare a estendere le funzionalità LUIS e App, aggiungendo funzionalità aggiuntive per gli oggetti nella scena; Ad esempio, creare nuovi oggetti nel punto di hit point dello sguardo fisso, a seconda di ciò che l'utente dice e quindi essere in grado di usare tali oggetti insieme agli oggetti scena correnti, con i comandi esistenti.