HoloLens (1ª geração) e Azure 303: LUIS (reconhecimento vocal natural)
Observação
Os tutoriais do Mixed Reality Academy foram projetados com o HoloLens (1ª geração) e os headsets imersivos de realidade misturada em mente. Dessa forma, achamos que é importante continuar disponibilizando esses tutoriais para os desenvolvedores que ainda buscam obter diretrizes para o desenvolvimento visando esses dispositivos. Esses tutoriais não serão atualizados com os conjuntos de ferramentas mais recentes nem com as interações usadas para o HoloLens 2. Eles serão mantidos para continuar funcionando nos dispositivos compatíveis. Haverá uma nova série de tutoriais que serão postados no futuro que demonstrarão como desenvolver para HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando eles forem postados.
Neste curso, você aprenderá a integrar Reconhecimento vocal a um aplicativo de realidade misturada usando os Serviços Cognitivos do Azure, com a API Reconhecimento vocal.
Reconhecimento vocal (LUIS) é um serviço do Microsoft Azure, que fornece aos aplicativos a capacidade de fazer sentido com a entrada do usuário, como extrair o que uma pessoa pode querer, em suas próprias palavras. Isso é obtido por meio do aprendizado de máquina, que entende e aprende as informações de entrada e, em seguida, pode responder com informações detalhadas e relevantes. Para obter mais informações, visite a página do LUIS (Reconhecimento vocal do Azure).
Depois de concluir este curso, você terá um aplicativo de headset imersivo de realidade misturada que poderá fazer o seguinte:
- Capture a fala de entrada do usuário usando o Microfone anexado ao headset imersivo.
- Envie o ditado capturado para o LUIS (Serviço Inteligente Reconhecimento vocal) do Azure.
- Faça com que o LUIS extraia o significado das informações de envio, que serão analisadas e tente determinar a intenção da solicitação do usuário.
O desenvolvimento incluirá a criação de um aplicativo em que o usuário poderá usar voz e/ou foco para alterar o tamanho e a cor dos objetos na cena. O uso de controladores de movimento não será abordado.
Em seu aplicativo, cabe a você saber como você integrará os resultados ao seu design. Este curso foi projetado para ensinar como integrar um Serviço do Azure ao seu Projeto do Unity. É seu trabalho usar o conhecimento obtido com este curso para aprimorar seu aplicativo de realidade misturada.
Prepare-se para treinar o LUIS várias vezes, que é abordado no Capítulo 12. Você obterá melhores resultados quanto mais vezes o LUIS tiver sido treinado.
Suporte a dispositivos
| Curso | HoloLens | Headsets imersivos |
|---|---|---|
| MR e Azure 303: LUIS (reconhecimento vocal natural) | ✔️ | ✔️ |
Observação
Embora este curso se concentre principalmente em Windows Mixed Reality headsets imersivos (VR), você também pode aplicar o que aprende neste curso a Microsoft HoloLens. Ao acompanhar o curso, você verá anotações sobre as alterações que talvez precise empregar para dar suporte ao HoloLens. Ao usar o HoloLens, você pode observar algum eco durante a captura de voz.
Pré-requisitos
Observação
Este tutorial foi projetado para desenvolvedores que têm experiência básica com Unity e C#. Lembre-se também de que os pré-requisitos e as instruções escritas neste documento representam o que foi testado e verificado no momento da gravação (maio de 2018). Você é livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não se presuma que as informações neste curso corresponderão perfeitamente ao que você encontrará no software mais recente do que o listado abaixo.
Recomendamos o seguinte hardware e software para este curso:
- Um computador de desenvolvimento, compatível com Windows Mixed Reality para desenvolvimento imersivo de headset (VR)
- Windows 10 Fall Creators Update (ou posterior) com o modo desenvolvedor habilitado
- O SDK do Windows 10 mais recente
- Unity 2017.4
- Visual Studio 2017
- Um headset (VR) imersivo Windows Mixed Reality ou Microsoft HoloLens com o modo desenvolvedor habilitado
- Um conjunto de fones de ouvido com um microfone interno (se o fone de ouvido não tiver um microfone interno e alto-falantes)
- Acesso à Internet para instalação do Azure e recuperação do LUIS
Antes de começar
Para evitar problemas ao criar esse projeto, é altamente sugerido que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pasta longa podem causar problemas no tempo de build).
Para permitir que seu computador habilite o Ditado, acesse Política de Privacidade > de Configurações > do Windows, Escrita à Tinta & Digitação e pressione o botão Ativar serviços de fala e digitar sugestões.
O código neste tutorial permitirá que você registre a partir do dispositivo de microfone padrão definido em seu computador. Verifique se o Dispositivo de Microfone Padrão está definido como aquele que você deseja usar para capturar sua voz.
Se o fone de ouvido tiver um microfone interno, verifique se a opção "Quando eu usar meu fone de ouvido, alterne para o microfone do fone de ouvido" está ativada nas configurações do portal Realidade Misturada.
Capítulo 1 – Configurar o Portal do Azure
Para usar o serviço Reconhecimento vocal no Azure, você precisará configurar uma instância do serviço a ser disponibilizada para seu aplicativo.
Faça logon no Portal do Azure.
Observação
Se você ainda não tiver uma conta do Azure, precisará criar uma. Se você estiver seguindo este tutorial em uma situação de sala de aula ou laboratório, peça ajuda ao instrutor ou a um dos supervisores para configurar sua nova conta.
Depois de fazer logon, clique em Novo no canto superior esquerdo e pesquise Reconhecimento vocal e clique em Enter.
Observação
A palavra Novo pode ter sido substituída por Criar um recurso, em portais mais recentes.
A nova página à direita fornecerá uma descrição do serviço Reconhecimento vocal. Na parte inferior esquerda desta página, selecione o botão Criar para criar uma instância desse serviço.
Depois de clicar em Criar:
Insira o Nome desejado para esta instância de serviço.
Selecione uma Assinatura.
Selecione o Tipo de Preço apropriado para você, se esta for a primeira vez que criar um serviço LUIS, uma camada gratuita (chamada F0) deverá estar disponível para você. A alocação gratuita deve ser mais do que suficiente para este curso.
Escolha um Grupo de Recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os serviços do Azure associados a um único projeto (por exemplo, como esses cursos) em um grupo de recursos comum).
Se você quiser ler mais sobre os Grupos de Recursos do Azure, visite o artigo do grupo de recursos.
Determine o Local do grupo de recursos (se você estiver criando um novo Grupo de Recursos). O local seria idealmente na região em que o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões.
Você também precisará confirmar que entendeu os Termos e Condições aplicados a esse Serviço.
Selecione Criar.
Depois de clicar em Criar, você precisará aguardar a criação do serviço, isso pode levar um minuto.
Uma notificação será exibida no portal depois que a instância de Serviço for criada.
Clique na notificação para explorar sua nova instância de Serviço.
Clique no botão Ir para o recurso na notificação para explorar sua nova instância de Serviço. Você será levado para sua nova instância de serviço do LUIS.
Neste tutorial, seu aplicativo precisará fazer chamadas para seu serviço, o que é feito usando a Chave de Assinatura do serviço.
Na página Início rápido , do serviço de API do LUIS , navegue até a primeira etapa, Pegue suas chaves e clique em Chaves (você também pode fazer isso clicando nas Teclas de hiperlink azul, localizadas no menu de navegação dos serviços, indicadas pelo ícone de chave). Isso revelará suas chaves de serviço.
Pegue uma cópia de uma das chaves exibidas, pois você precisará disso mais tarde em seu projeto.
Na página Serviço, clique em Reconhecimento vocal Portal para ser redirecionado para a página da Web que você usará para criar seu novo Serviço, dentro do Aplicativo LUIS.
Capítulo 2 – Portal do Reconhecimento vocal
Nesta seção, você aprenderá a criar um aplicativo LUIS no Portal do LUIS.
Importante
Lembre-se de que a configuração de Entidades, Intenções e Enunciados neste capítulo é apenas a primeira etapa na criação do serviço LUIS: você também precisará treinar novamente o serviço, várias vezes, para torná-lo mais preciso. O retreinamento do serviço é abordado no último Capítulo deste curso, portanto, certifique-se de concluí-lo.
Ao chegar ao portal do Reconhecimento vocal, talvez seja necessário fazer logon, se ainda não estiver, com as mesmas credenciais que o portal do Azure.
Se esta for sua primeira vez usando o LUIS, você precisará rolar para baixo até a parte inferior da página de boas-vindas para localizar e clicar no botão Criar aplicativo LUIS .
Depois de conectado, clique em Meus aplicativos (se você não estiver nessa seção no momento). Em seguida, você pode clicar em Criar novo aplicativo.
Dê um Nome para o aplicativo.
Se seu aplicativo deve entender um idioma diferente do inglês, você deve alterar a Cultura para o idioma apropriado.
Aqui você também pode adicionar uma Descrição do seu novo aplicativo LUIS.
Depois de pressionar Concluído, você entrará na página Compilar do novo aplicativo LUIS .
Há alguns conceitos importantes a serem compreendidos aqui:
- Intent representa o método que será chamado após uma consulta do usuário. Uma INTENT pode ter uma ou mais ENTIDADES.
- Entidade é um componente da consulta que descreve informações relevantes para a INTENT.
- Enunciados são exemplos de consultas fornecidas pelo desenvolvedor, que o LUIS usará para se treinar.
Se esses conceitos não forem perfeitamente claros, não se preocupe, pois este curso os esclarecerá ainda mais neste capítulo.
Você começará criando as Entidades necessárias para criar este curso.
No lado esquerdo da página, clique em Entidades e, em seguida, clique em Criar nova entidade.
Chame a nova Cor da entidade, defina seu tipo como Simples e pressione Done.
Repita esse processo para criar mais três (3) entidades simples chamadas:
- upsize
- Reduzir
- destino
O resultado deve ser semelhante à imagem abaixo:
Neste ponto, você pode começar a criar Intenções.
Aviso
Não exclua a intenção None .
No lado esquerdo da página, clique em Intenções e, em seguida, clique em Criar nova intenção.
Chame a nova IntençãoChangeObjectColor.
Importante
Esse nome de intenção é usado no código posteriormente neste curso, portanto, para obter melhores resultados, use esse nome exatamente conforme fornecido.
Depois de confirmar o nome, você será direcionado para a Página de Intenções.
Você observará que há uma caixa de texto solicitando que você digite 5 ou mais enunciados diferentes.
Observação
O LUIS converte todos os Enunciados em letras minúsculas.
- Insira o seguinte Enunciado na caixa de texto superior (atualmente com o texto Digite cerca de 5 exemplos... ) e pressione Enter:
The color of the cylinder must be red
Você observará que o novo Enunciado aparecerá em uma lista abaixo.
Seguindo o mesmo processo, insira os seguintes seis (6) enunciados:
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
Para cada Enunciado criado, você deve identificar quais palavras devem ser usadas pelo LUIS como Entidades. Neste exemplo, você precisa rotular todas as cores como uma entidade de cor e toda a referência possível a um destino como uma Entidade de destino .
Para fazer isso, tente clicar na palavra cilindro no primeiro Enunciado e selecione destino.
Agora, clique na palavra vermelho no primeiro Enunciado e selecione cor.
Rotule a próxima linha também, em que o cubo deve ser um destino e preto deve ser uma cor. Observe também o uso das palavras 'this', 'it' e 'this object', que estamos fornecendo, portanto, para ter tipos de destino não específicos disponíveis também.
Repita o processo acima até que todos os Enunciados tenham as Entidades rotuladas. Consulte a imagem abaixo se precisar de ajuda.
Dica
Ao selecionar palavras para rotulá-las como entidades:
- Para palavras simples, basta clicar nelas.
- Para um conjunto de duas ou mais palavras, clique no início e no final do conjunto.
Observação
Você pode usar o botão de alternância Exibição de Tokens para alternar entre Entidades/Exibição de Tokens!
Os resultados devem ser como visto nas imagens abaixo, mostrando a exibição Entidades/Tokens:
Neste ponto, pressione o botão Treinar no canto superior direito da página e aguarde até que o indicador redondo pequeno sobre ele fique verde. Isso indica que o LUIS foi treinado com êxito para reconhecer essa Intenção.
Como um exercício para você, crie uma nova Intenção chamada ChangeObjectSize, usando o destinoEntidades, o upsize e o downsize.
Seguindo o mesmo processo da Intenção anterior, insira os seguintes oito (8) enunciados para Alteração de tamanho :
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 objectO resultado deve ser semelhante ao mostrado na imagem abaixo:
Depois que ambas as Intenções, ChangeObjectColor e ChangeObjectSize tiverem sido criadas e treinadas, clique no botão PUBLICAR na parte superior da página.
Na página Publicar , você finalizará e publicará seu aplicativo LUIS para que ele possa ser acessado pelo código.
Defina a lista suspensa Publicar para como Produção.
Defina o Fuso horário como seu fuso horário.
Marque a caixa Incluir todas as pontuações de intenção previstas.
Clique em Publicar no Slot de Produção.
Na seção Recursos e Chaves:
- Selecione a região definida para a instância de serviço no Portal do Azure.
- Você observará um elemento Starter_Key abaixo, ignore-o.
- Clique em Adicionar Chave e insira a Chave obtida no Portal do Azure ao criar sua instância de Serviço. Se o Azure e o portal do LUIS estiverem conectados ao mesmo usuário, você receberá menus suspensos para Nome do locatário, Nome da Assinatura e a Chave que você deseja usar (terá o mesmo nome fornecido anteriormente no Portal do Azure.
Importante
Abaixo do ponto de extremidade, faça uma cópia do ponto de extremidade correspondente à Chave que você inseriu e, em breve, você a usará em seu código.
Capítulo 3 – Configurar o projeto do Unity
Veja a seguir uma configuração típica para o desenvolvimento com a realidade misturada e, como tal, é um bom modelo para outros projetos.
Abra o Unity e clique em Novo.
Agora você precisará fornecer um nome de Projeto do Unity, inserir MR_LUIS. Verifique se o tipo de projeto está definido como 3D. Defina o Local como em algum lugar apropriado para você (lembre-se de que mais perto dos diretórios raiz é melhor). Em seguida, clique em Criar projeto.
Com o Unity aberto, vale a pena verificar se o Editor de Scripts padrão está definido como Visual Studio. Vá para Editar > Preferências e, em seguida, na nova janela, navegue até Ferramentas Externas. Altere o Editor de Script Externo para o Visual Studio 2017. Feche a janela Preferências.
Em seguida, vá para Configurações de Build de Arquivo > e alterne a plataforma para Plataforma Universal do Windows, clicando no botão Alternar Plataforma.
Vá para Configurações de Build de Arquivo > e verifique se:
O dispositivo de destino é definido como Qualquer Dispositivo
Para o Microsoft HoloLens, defina Dispositivo de Destino como HoloLens.
O Tipo de Build é definido como D3D
O SDK está definido como Mais recente instalado
A versão do Visual Studio está definida como Mais Recente instalada
Compilar e Executar é definido como Computador Local
Salve a cena e adicione-a ao build.
Faça isso selecionando Adicionar Cenas Abertas. Uma janela de salvamento será exibida.
Crie uma nova pasta para essa e qualquer cena futura e, em seguida, selecione o botão Nova pasta para criar uma nova pasta, nomeie-a cenas.
Abra a pasta Cenas recém-criada e, em seguida, no campo Nome do arquivo: texto, digite MR_LuisScene e pressione Salvar.
As configurações restantes, em Configurações de Build, devem ser deixadas como padrão por enquanto.
Na janela Configurações de Build, clique no botão Configurações do Player , isso abrirá o painel relacionado no espaço em que o Inspetor está localizado.
Neste painel, algumas configurações precisam ser verificadas:
Na guia Outras Configurações :
A versão de runtime de script deve ser estável (equivalente ao .NET 3.5).
O back-end de script deve ser .NET
O Nível de Compatibilidade da API deve ser .NET 4.6
Na guia Configurações de Publicação, em Recursos, marcar:
InternetClient
Microfone
Mais abaixo no painel, em Configurações de XR (encontradas abaixo de Configurações de Publicação), marque Com suporte à Realidade Virtual, verifique se o SDK do Windows Mixed Reality foi adicionado.
De volta às Configurações de Build, os projetos C# do Unity não estão mais esmaecidos; marque a caixa de seleção ao lado disso.
Feche a janela Configurações de Build.
Salve a Cena e o Projeto (FILE > SAVE SCENE/FILE > SAVE PROJECT).
Capítulo 4 – Criar a cena
Importante
Se você quiser ignorar o componente Configurar do Unity deste curso e continuar diretamente no código, fique à vontade para baixar este .unitypackage, importe-o para seu projeto como um Pacote Personalizado e continue a partir do Capítulo 5.
Clique com o botão direito do mouse em uma área vazia do Painel de Hierarquia, em Objeto 3D, adicione um Plano.
Lembre-se de que quando você clicar com o botão direito do mouse na Hierarquia novamente para criar mais objetos, se ainda tiver o último objeto selecionado, o objeto selecionado será o pai do novo objeto. Evite esse clique à esquerda em um espaço vazio dentro da Hierarquia e clique com o botão direito do mouse.
Repita o procedimento acima para adicionar os seguintes objetos:
- Sphere
- Cilindro
- Cube
- Texto 3D
A cena resultante Hierarquia deve ser semelhante à da imagem abaixo:
Clique com o botão esquerdo do mouse na Câmera Principal para selecioná-la, examine o Painel do Inspetor que você verá o objeto Câmera com todos os componentes.
Clique no botão Adicionar Componente localizado na parte inferior do Painel do Inspetor.
Pesquise o componente chamado Fonte de Áudio, conforme mostrado acima.
Verifique também se o componente Transformar da Câmera Principal está definido como (0,0,0), isso pode ser feito pressionando o ícone Engrenagem ao lado do componente Transformação da Câmera e selecionando Redefinir. Em seguida, o componente Transformar deve ter a seguinte aparência:
- A posição é definida como 0, 0, 0.
- A rotação é definida como 0, 0, 0.
Observação
Para o Microsoft HoloLens, você também precisará alterar o seguinte, que faz parte do componente Câmera, que está em sua Câmera Principal:
- Limpar Sinalizadores: Cor Sólida.
- Fundo 'Preto, Alfa 0' – Cor hexadecima: #00000000.
Clique com o botão esquerdo do mouse no Plano para selecioná-lo. No Painel do Inspetor , defina o componente Transformar com os seguintes valores:
Eixo X Eixo Y Eixo Z 0 -1 0 Clique com o botão esquerdo do mouse no Sphere para selecioná-lo. No Painel do Inspetor , defina o componente Transformar com os seguintes valores:
Eixo X Eixo Y Eixo Z 2 1 2 Clique com o botão esquerdo do mouse no Cilindro para selecioná-lo. No Painel do Inspetor , defina o componente Transformar com os seguintes valores:
Eixo X Eixo Y Eixo Z -2 1 2 Clique com o botão esquerdo do mouse no Cubo para selecioná-lo. No Painel do Inspetor , defina o componente Transformar com os seguintes valores:
Transformação – Posição
| X | S | Z |
|---|---|---|
| 0 | 1 | 4 |
Transformação – Rotação
| X | S | Z |
|---|---|---|
| 45 | 45 | 0 |
- Clique com o botão esquerdo do mouse no objeto Novo Texto para selecioná-lo. No Painel do Inspetor , defina o componente Transformar com os seguintes valores:
Transformação – Posição
| X | S | Z |
|---|---|---|
| -2 | 6 | 9 |
Transformar – Dimensionar
| X | S | Z |
|---|---|---|
| 0,1 | 0,1 | 0,1 |
Altere o Tamanho da Fonte no componente Malha de Texto para 50.
Altere o nome do objeto Malha de Texto para Texto de Ditado.
Sua estrutura do Painel de Hierarquia agora deve ter esta aparência:
A cena final deve se parecer com a imagem abaixo:
Capítulo 5 – Criar a classe MicrophoneManager
O primeiro Script que você vai criar é a classe MicrophoneManager . Depois disso, você criará o LuisManager, a classe Behaviors e, por fim, a classe Gaze (fique à vontade para criar tudo isso agora, embora ela seja abordada conforme você chegar a cada Capítulo).
A classe MicrophoneManager é responsável por:
- Detectando o dispositivo de gravação anexado ao fone de ouvido ou computador (o que for o padrão).
- Capture o áudio (voz) e use o ditado para armazená-lo como uma cadeia de caracteres.
- Depois que a voz for pausada, envie o ditado para a classe LuisManager .
Para criar essa classe:
Clique com o botão direito do mouse no Painel de Projeto, Criar > Pasta. Chame a pasta Scripts.
Com a pasta Scripts criada, clique duas vezes nela para abrir. Em seguida, dentro dessa pasta, clique com o botão direito do mouse em Criar > Script C#. Nomeie o script MicrophoneManager.
Clique duas vezes em MicrophoneManager para abri-lo com o Visual Studio.
Adicione os seguintes namespaces à parte superior do arquivo:
using UnityEngine; using UnityEngine.Windows.Speech;Em seguida, adicione as seguintes variáveis dentro da 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 resultO código para métodos Awake() e Start() agora precisa ser adicionado. Eles serão chamados quando a classe inicializar:
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"); } }Agora você precisa do método que o Aplicativo usa para iniciar e parar a captura de voz e passá-la para a classe LuisManager , que você criará em 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..."); }Adicione um Manipulador de Ditado que será invocado quando a voz for pausada. Esse método passará o texto de ditado para a 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
Exclua o método Update(), pois essa classe não o usará.
Salve suas alterações no Visual Studio antes de retornar ao Unity.
Observação
Neste ponto, você observará um erro aparecendo no Painel de Console do Editor do Unity. Isso ocorre porque o código faz referência à classe LuisManager que você criará no próximo Capítulo.
Capítulo 6 – Criar a classe LUISManager
É hora de você criar a classe LuisManager , que fará a chamada para o serviço LUIS do Azure.
A finalidade dessa classe é receber o texto de ditado da classe MicrophoneManager e enviá-lo para a API de Reconhecimento vocal do Azure a ser analisada.
Essa classe desserializará a resposta JSON e chamará os métodos apropriados da classe Behaviors para disparar uma ação.
Para criar essa classe:
Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse na pasta Scripts e clique em Criar > Script C#. Nomeie o script LuisManager.
Clique duas vezes no script para abri-lo com o Visual Studio.
Adicione os seguintes namespaces à parte superior do arquivo:
using System; using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using UnityEngine.Networking;Você começará criando três classes dentro da classe LuisManager (dentro do mesmo arquivo de script, acima do método Start() que representará a resposta JSON desserializada do 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; }Em seguida, adicione as seguintes variáveis dentro da 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";Certifique-se de colocar o ponto de extremidade do LUIS no agora (que você terá no portal do LUIS).
O código para o método Awake() agora precisa ser adicionado. Esse método será chamado quando a classe inicializar:
private void Awake() { // allows this class instance to behave like a singleton instance = this; }Agora você precisa dos métodos que este aplicativo usa para enviar o ditado recebido da classe MicrophoneManager para o LUIS e, em seguida, receber e desserializar a resposta.
Depois que o valor da Intenção e das Entidades associadas tiverem sido determinados, eles serão passados para a instância da classe Behaviors para disparar a ação pretendida.
/// <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; } }Crie um novo método chamado AnalyzeResponseElements() que lerá o AnalyzeedQuery resultante e determinará as Entidades. Depois que essas Entidades forem determinadas, elas serão passadas para a instância da classe Behaviors a ser usada nas ações.
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
Exclua os métodos Start() e Update(), pois essa classe não os usará.
Salve suas alterações no Visual Studio antes de retornar ao Unity.
Observação
Neste ponto, você observará vários erros que aparecem no Painel de Console do Editor do Unity. Isso ocorre porque o código faz referência à classe Behaviors que você criará no próximo Capítulo.
Capítulo 7 – Criar a classe Behaviors
A classe Behaviors disparará as ações usando as Entidades fornecidas pela classe LuisManager .
Para criar essa classe:
Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse na pasta Scripts e clique em Criar > Script C#. Nomeie o script Comportamentos.
Clique duas vezes no script para abri-lo com o Visual Studio.
Em seguida, adicione as seguintes variáveis dentro da 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;Adicione o código do método Awake( ). Esse método será chamado quando a classe inicializar:
void Awake() { // allows this class instance to behave like a singleton instance = this; }Os métodos a seguir são chamados pela classe LuisManager (que você criou anteriormente) para determinar qual objeto é o destino da consulta e, em seguida, disparar a ação apropriada.
/// <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); }Adicione o método FindTarget() para determinar qual dos GameObjects é o destino da Intenção atual. Esse método usa como padrão o destino para o GameObject ser "direcionado" se nenhum destino explícito for definido nas Entidades.
/// <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
Exclua os métodos Start() e Update(), pois essa classe não os usará.
Salve suas alterações no Visual Studio antes de retornar ao Unity.
Capítulo 8 – Criar a classe Gaze
A última classe que você precisará para concluir este aplicativo é a classe Gaze . Essa classe atualiza a referência ao GameObject atualmente no foco visual do usuário.
Para criar esta Classe:
Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse na pasta Scripts e clique em Criar > Script C#. Nomeie o script como Foco.
Clique duas vezes no script para abri-lo com o Visual Studio.
Insira o seguinte código para esta 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; } } }Salve as alterações no Visual Studio antes de retornar ao Unity.
Capítulo 9 – Concluindo a configuração da cena
Para concluir a configuração da cena, arraste cada script que você criou da Pasta Scripts para o objeto Câmera Principal no Painel hierarquia.
Selecione a Câmera Principal e examine o Painel do Inspetor, você poderá ver cada script anexado e observará que há parâmetros em cada script que ainda estão para ser definidos.
Para definir esses parâmetros corretamente, siga estas instruções:
MicrophoneManager:
- No Painel hierarquia, arraste o objeto Texto de Ditado para a caixa de valor do parâmetro Texto de Ditado .
Comportamentos, no Painel de Hierarquia:
- Arraste o objeto Sphere para a caixa de destino de referência do Sphere .
- Arraste o Cilindro para a caixa de destino de referência do Cilindro .
- Arraste o Cubo para a caixa De destino de referência do cubo .
Foco:
- Defina a Distância Máxima de Foco como 300 (se ainda não estiver).
O resultado deve ser semelhante à imagem abaixo:
Capítulo 10 – Testar no Editor do Unity
Teste se a configuração de Cena foi implementada corretamente.
Verifique se:
- Todos os scripts são anexados ao objeto Câmera Principal .
- Todos os campos no Painel Principal do Inspetor de Câmera são atribuídos corretamente.
Pressione o botão Reproduzir no Editor do Unity. O aplicativo deve estar em execução no headset imersivo anexado.
Experimente alguns enunciados, como:
make the cylinder red change the cube to yellow I want the sphere blue make this to green change it to whiteObservação
Se você vir um erro no console do Unity sobre a alteração do dispositivo de áudio padrão, a cena pode não funcionar conforme o esperado. Isso ocorre devido à maneira como o portal de realidade misturada lida com microfones internos para headsets que os têm. Se você vir esse erro, basta parar a cena e iniciá-la novamente e as coisas devem funcionar conforme o esperado.
Capítulo 11 – Compilar e fazer sideload da solução UWP
Depois de garantir que o aplicativo está funcionando no Editor do Unity, você estará pronto para Compilar e Implantar.
Para compilar:
Salve a cena atual clicando em Salvar Arquivo>.
Vá para Configurações de Build de Arquivo>.
Marque a caixa chamada Projetos C# do Unity (útil para ver e depurar seu código depois que o projeto UWP é criado.
Clique em Adicionar Cenas Abertas e, em seguida, clique em Compilar.
Você será solicitado a selecionar a pasta na qual deseja compilar a Solução.
Crie uma pasta BUILDS e, dentro dessa pasta, crie outra pasta com um nome apropriado de sua escolha.
Clique em Selecionar Pasta para iniciar o build nesse local.
Depois que o Unity terminar de compilar (pode levar algum tempo), ele deverá abrir uma janela Explorador de Arquivos no local do build.
Para implantar no computador local:
No Visual Studio, abra o arquivo de solução que foi criado no Capítulo anterior.
Na Plataforma de Solução, selecione x86, Computador Local.
Na Configuração da Solução , selecione Depurar.
Para o Microsoft HoloLens, talvez seja mais fácil defini-lo como Computador Remoto, para que você não seja vinculado ao computador. No entanto, você também precisará fazer o seguinte:
- Conheça o endereço IP do HoloLens, que pode ser encontrado na Rede de Configurações & Opções Avançadas > Wi-Fi > internet>; o IPv4 é o endereço que você deve usar.
- Verifique se o Modo de Desenvolvedor está Ativado; encontrado em Configurações > Atualização & Segurança > para desenvolvedores.
Vá para o menu Compilar e clique em Implantar Solução para fazer sideload do aplicativo em seu computador.
Seu aplicativo agora deve aparecer na lista de aplicativos instalados, prontos para serem iniciados!
Depois de iniciado, o aplicativo solicitará que você autorize o acesso ao Microfone. Use os Controladores de Movimento, a Entrada de Voz ou o Teclado para pressionar o botão SIM .
Capítulo 12 – Como melhorar seu serviço LUIS
Importante
Este capítulo é incrivelmente importante e pode precisar ser iterado várias vezes, pois ajudará a melhorar a precisão do serviço luis: verifique se você concluiu isso.
Para melhorar o nível de compreensão fornecido pelo LUIS, você precisa capturar novos enunciados e usá-los para treinar novamente seu aplicativo LUIS.
Por exemplo, você pode ter treinado o LUIS para entender "Aumentar" e "Upsize", mas não gostaria que seu aplicativo também entendesse palavras como "Ampliar"?
Depois de usar seu aplicativo algumas vezes, tudo o que você disse será coletado pelo LUIS e estará disponível no PORTAL do LUIS.
Acesse o aplicativo do portal seguindo este LINK e faça logon.
Depois de fazer logon com suas Credenciais ms, clique em seu Nome do aplicativo.
Clique no botão Examinar enunciados do ponto de extremidade à esquerda da página.
Você verá uma lista dos Enunciados que foram enviados ao LUIS pelo aplicativo de realidade misturada.
Você observará algumas Entidades realçadas.
Ao passar o mouse sobre cada palavra realçada, você pode examinar cada Enunciado e determinar qual Entidade foi reconhecida corretamente, quais Entidades estão erradas e quais Entidades são perdidas.
No exemplo acima, descobriu-se que a palavra "lança" tinha sido realçada como um destino, portanto, é necessário corrigir o erro, o que é feito passando o mouse sobre a palavra e clicando em Remover Rótulo.
Se você encontrar enunciados completamente errados, poderá excluí-los usando o botão Excluir no lado direito da tela.
Ou, se você achar que o LUIS interpretou o Enunciado corretamente, poderá validar sua compreensão usando o botão Adicionar à Intenção Alinhada .
Depois de classificar todos os Enunciados exibidos, tente recarregar a página para ver se mais estão disponíveis.
É muito importante repetir esse processo o máximo de vezes possível para melhorar a compreensão do aplicativo.
Divirta-se!
Seu aplicativo integrado do LUIS concluído
Parabéns, você criou um aplicativo de realidade misturada que aproveita o Serviço de Inteligência Reconhecimento vocal do Azure, para entender o que um usuário diz e agir sobre essas informações.
Exercícios de bônus
Exercício 1
Ao usar esse aplicativo, você pode observar que, se você olhar para o objeto Floor e pedir para alterar sua cor, ele o fará. Você pode descobrir como impedir que seu aplicativo altere a cor do piso?
Exercício 2
Tente estender as funcionalidades do LUIS e do aplicativo, adicionando funcionalidade adicional para objetos em cena; por exemplo, crie novos objetos no ponto de ocorrência gaze, dependendo do que o usuário diz e, em seguida, seja capaz de usar esses objetos ao lado de objetos de cena atuais, com os comandos existentes.