HoloLens (1.ª geração) e Azure 307: Machine learning
Nota
Os tutoriais da Academia de Realidade Mista foram projetados com HoloLens (1ª geração) e Headsets Imersivos de Realidade Mista em mente. Como tal, sentimos que é importante deixar estes tutoriais no lugar para desenvolvedores que ainda estão procurando orientação no desenvolvimento para esses dispositivos. Esses tutoriais não serão atualizados com os conjuntos de ferramentas ou interações mais recentes que estão sendo usados para o HoloLens 2. Eles serão mantidos para continuar trabalhando nos dispositivos suportados. Haverá uma nova série de tutoriais que serão publicados no futuro que demonstrarão como desenvolver para o HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando eles forem publicados.
Neste curso, você aprenderá como adicionar recursos de Machine Learning (ML) a um aplicativo de realidade mista usando o Azure Machine Learning Studio (clássico).
O Azure Machine Learning Studio (clássico) é um serviço da Microsoft que fornece aos desenvolvedores um grande número de algoritmos de aprendizado de máquina, que podem ajudar na entrada, saída, preparação e visualização de dados. A partir desses componentes, é possível desenvolver um experimento de análise preditiva, iterá-lo e usá-lo para treinar seu modelo. Após o treinamento, você pode tornar seu modelo operacional na nuvem do Azure, para que ele possa pontuar novos dados. Para obter mais informações, visite a página Azure Machine Learning Studio (clássico).
Tendo concluído este curso, você terá um aplicativo de fone de ouvido imersivo de realidade mista, e terá aprendido como fazer o seguinte:
- Forneça uma tabela de dados de vendas para o portal do Azure Machine Learning Studio (clássico) e projete um algoritmo para prever vendas futuras de itens populares.
- Crie um projeto Unity, que pode receber e interpretar dados de previsão do serviço de ML.
- Exiba os dados de predicação visualmente dentro do Projeto Unity, fornecendo os itens de vendas mais populares, em uma prateleira.
Na sua aplicação, cabe-lhe a si decidir como irá integrar os resultados com o seu design. Este curso foi criado para ensiná-lo a integrar um Serviço do Azure ao seu Projeto Unity. É seu trabalho usar o conhecimento que você ganha com este curso para melhorar sua aplicação de realidade mista.
Este curso é um tutorial independente, que não envolve diretamente nenhum outro Laboratório de Realidade Mista.
Suporte de dispositivos
| Curso | HoloLens | Auriculares imersivos |
|---|---|---|
| MR e Azure 307: Aprendizagem automática | ✔️ | ✔️ |
Nota
Embora este curso se concentre principalmente em fones de ouvido imersivos (VR) do Windows Mixed Reality, você também pode aplicar o que aprendeu neste curso ao Microsoft HoloLens. À medida que você acompanha o curso, você verá anotações sobre quaisquer alterações que você possa precisar empregar para dar suporte ao HoloLens. Ao utilizar o HoloLens, poderá notar algum eco durante a captura de voz.
Pré-requisitos
Nota
Este tutorial foi projetado para desenvolvedores que têm experiência básica com Unity e C#. Por favor, esteja ciente de que os pré-requisitos e instruções escritas neste documento representam o que foi testado e verificado no momento da redação (maio de 2018). Você é livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas, embora não se deva presumir que as informações neste curso corresponderão perfeitamente ao que você encontrará em software mais recente do que o listado abaixo.
Recomendamos o seguinte hardware e software para este curso:
- Um PC de desenvolvimento, compatível com Windows Mixed Reality para desenvolvimento imersivo (VR) de auriculares
- Windows 10 Fall Creators Update (ou posterior) com o modo de desenvolvedor ativado
- O SDK mais recente do Windows 10
- Unidade 2017.4
- Visual Studio 2017
- Um auricular imersivo (VR) Windows Mixed Reality ou Microsoft HoloLens com o modo de programador ativado
- Acesso à Internet para configuração do Azure e recuperação de dados de ML
Antes de começar
Para evitar encontrar problemas ao criar este projeto, é altamente recomendável que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pasta longos podem causar problemas em tempo de compilação).
Capítulo 1 - Configuração da Conta de Armazenamento do Azure
Para usar a API do Tradutor do Azure, você precisará configurar uma instância do serviço a ser disponibilizada para seu aplicativo.
Inicie sessão no Portal do Azure.
Nota
Se ainda não tiver uma conta do Azure, terá de criar uma. Se você estiver seguindo este tutorial em uma situação de sala de aula ou laboratório, peça ajuda ao seu instrutor ou a um dos proctors para configurar sua nova conta.
Depois de iniciar sessão, clique em Contas de Armazenamento no menu à esquerda.
Nota
A palavra Novo pode ter sido substituída por Criar um recurso, em portais mais recentes.
Na guia Contas de armazenamento , clique em Adicionar.
No painel Criar conta de armazenamento:
Insira um Nome para a sua conta, esteja ciente de que este campo só aceita números e letras minúsculas.
Em Modelo de implantação, selecione Gerenciador de recursos.
Para Tipo de conta, selecione Armazenamento (finalidade geral v1).
Em Desempenho, selecione Standard.
Em Replicação, selecione Read-access-geo-redundant storage (RA-GRS).
Deixe a transferência segura necessária como Desativado.
Selecione uma Subscrição.
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 laboratórios) em um grupo de recursos comum).
Se desejar ler mais sobre os Grupos de Recursos do Azure, visite o artigo do grupo de recursos.
Determine a Localização do seu grupo de recursos (se estiver a criar um novo Grupo de Recursos). O ideal seria que o local fosse na região onde o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões.
Você também precisará confirmar que compreendeu os Termos e Condições aplicados a este Serviço.
Depois de clicar em Criar, você terá que esperar que o serviço seja criado, isso pode levar um minuto.
Uma notificação aparecerá no portal assim que a instância de serviço for criada.
Capítulo 2 - O Azure Machine Learning Studio (clássico)
Para usar o Aprendizado de Máquina do Azure, você precisará configurar uma instância do serviço de Aprendizado de Máquina a ser disponibilizada para seu aplicativo.
No Portal do Azure, clique em Novo no canto superior esquerdo e procure Espaço de Trabalho do Estúdio de Aprendizado de Máquina, pressione Enter.
A nova página fornecerá uma descrição do serviço de Espaço de Trabalho do Estúdio de Aprendizado de Máquina . No canto inferior esquerdo deste prompt, clique no botão Criar para criar uma associação com este serviço.
Depois de clicar em Criar, aparecerá um painel onde você precisa fornecer alguns detalhes sobre seu novo serviço do Machine Learning Studio:
Insira o nome do espaço de trabalho desejado para esta instância de serviço.
Selecione uma Subscrição.
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 laboratórios) em um grupo de recursos comum).
Se desejar ler mais sobre os Grupos de Recursos do Azure, visite o artigo do grupo de recursos.
Determine a Localização do seu grupo de recursos (se estiver a criar um novo Grupo de Recursos). O ideal seria que o local fosse na região onde o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões. Você deve usar o mesmo grupo de recursos usado para criar o Armazenamento do Azure no Capítulo anterior.
Na seção Conta de armazenamento, clique em Usar existente, clique no menu suspenso e, a partir daí, clique na Conta de armazenamento criada no último capítulo.
Selecione o nível de preço do Espaço de trabalho apropriado para você no menu suspenso.
Na seção Plano de serviço Web, clique em Criar novo e insira um nome para ele no campo de texto.
Na seção Nível de preço do plano de serviço Web, selecione o nível de preço de sua escolha. Uma camada de teste de desenvolvimento chamada DEVTEST Standard deve estar disponível para você gratuitamente.
Você também precisará confirmar que compreendeu os Termos e Condições aplicados a este Serviço.
Clique em Criar.
Depois de clicar em Criar, você terá que esperar que o serviço seja criado, isso pode levar um minuto.
Uma notificação aparecerá no portal assim 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 recurso na notificação para explorar sua nova instância de serviço.
Na página exibida, na seção Links Adicionais , clique em Iniciar o Estúdio de Aprendizado de Máquina, que direcionará seu navegador para o portal do Estúdio de Aprendizado de Máquina.
Use o botão Entrar , no canto superior direito ou no centro, para fazer login no seu Estúdio de Aprendizado de Máquina (clássico).
Capítulo 3 - O Estúdio de Aprendizado de Máquina (clássico): Configuração do conjunto de dados
Uma das maneiras como os algoritmos de Machine Learning funcionam é analisando os dados existentes e, em seguida, tentando prever resultados futuros com base no conjunto de dados existente. Isso geralmente significa que quanto mais dados existentes você tiver, melhor será o algoritmo para prever resultados futuros.
Uma tabela de exemplo é fornecida a você, para este curso, chamada ProductsTableCSV e pode ser baixada aqui.
Importante
O arquivo .zip acima contém o ProductsTableCSV e o .unitypackage, que você precisará no Capítulo 6. Este pacote também é fornecido dentro desse capítulo, embora separado para o arquivo csv.
Este conjunto de dados de exemplo contém um registro dos objetos mais vendidos a cada hora de cada dia do ano de 2017.
Por exemplo, no dia 1º de 2017, às 13h (hora 13), o item mais vendido foi sal e pimenta.
Esta tabela de exemplo contém 9998 entradas.
Volte para o portal do Estúdio de Aprendizado de Máquina (clássico) e adicione esta tabela como um conjunto de dados para seu ML. Para tal, clique no botão + Novo no canto inferior esquerdo do ecrã.
Uma seção virá de baixo e, dentro dela, há um painel de navegação à esquerda. Clique em Conjunto de dados e, em seguida, à direita disso, Do arquivo local.
Carregue o novo Dataset seguindo estas etapas:
A janela de upload aparecerá, onde você pode Procurar seu disco rígido para o novo conjunto de dados.
Uma vez selecionado, e de volta na janela de upload, deixe a caixa de seleção desmarcada.
No campo de texto abaixo, digite ProductsTableCSV.csv como o nome do conjunto de dados (embora deva ser adicionado automaticamente).
Usando o menu suspenso para Tipo, selecione Arquivo CSV genérico com um cabeçalho (.csv).
Pressione o tick no canto inferior direito da janela de upload e seu Dataset será carregado.
Capítulo 4 - O Estúdio de Aprendizado de Máquina (clássico): O Experimento
Antes de poder construir seu sistema de aprendizado de máquina, você precisará construir um experimento, para validar sua teoria sobre seus dados. Com os resultados, você saberá se precisa de mais dados ou se não há correlação entre os dados e um possível resultado.
Para começar a criar uma experiência:
Clique novamente no botão + Novo no canto inferior esquerdo da página e, em seguida, clique em Experiência em Branco>.
Uma nova página será exibida com um experimento em branco:
No painel à esquerda, expanda Conjuntos de>Dados Salvos Meus Conjuntos de Dados e arraste o ProductsTableCSV para a Tela de Experimento.
No painel à esquerda, expanda Exemplo de transformação>de dados e Dividir. Em seguida, arraste o item Dados Divididos para a Tela de Experimento. O item Dados divididos dividirá o conjunto de dados em duas partes. Uma parte que você usará para treinar o algoritmo de aprendizado de máquina. A segunda parte será usada para avaliar a precisão do algoritmo gerado.
No painel direito (enquanto o item Dados Divididos na tela estiver selecionado), edite a Fração de linhas no primeiro conjunto de dados de saída como 0,7. Isso dividirá os dados em duas partes, a primeira parte será 70% dos dados e a segunda parte será os 30% restantes. Para garantir que os dados sejam divididos aleatoriamente, verifique se a caixa de seleção Divisão aleatória permanece marcada.
Arraste uma conexão da base do item ProductsTableCSV na tela para a parte superior do item Split Data. Isso conectará os itens e enviará a saída do conjunto de dados ProductsTableCSV (os dados) para a entrada Split Data.
No painel Experimentos no lado esquerdo, expanda Trem de aprendizado de>máquina. Arraste o item Modelo de trem para a tela Experimento. Sua tela deve ter a mesma aparência que a abaixo.
No canto inferior esquerdo do item Dados divididos, arraste uma conexão para o canto superior direito do item Modelo de trem. A primeira divisão de 70% do conjunto de dados será usada pelo Modelo Train para treinar o algoritmo.
Selecione o item Modelo de trem na tela e, no painel Propriedades (no lado direito da janela do navegador), clique no botão seletor de coluna Iniciar.
Na caixa de texto, digite produto e pressione Enter, o produto será definido como uma coluna para treinar previsões. Depois disso, clique no tick no canto inferior direito para fechar a caixa de diálogo de seleção.
Você vai treinar um algoritmo de Regressão Logística Multiclasse para prever o produto mais vendido com base na hora do dia e na data. Está além do escopo deste documento explicar os detalhes dos diferentes algoritmos fornecidos pelo estúdio Azure Machine Learning, no entanto, você pode descobrir mais no Machine Learning Algorithm Cheat Sheet
No painel de itens do experimento à esquerda, expanda Classificação do Modelo>de Inicialização do Aprendizado de Máquina> e arraste o item Regressão Logística Multiclasse para a tela do experimento.
Conecte a saída, da parte inferior da Regressão Logística Multiclasse, à entrada superior esquerda do item Modelo de trem.
Na lista de itens de experimento no painel à esquerda, expanda Pontuação do Aprendizado>de Máquina e arraste o item Modelo de Pontuação para a tela.
Conecte a saída, da parte inferior do Modelo de Trem, à entrada superior esquerda do Modelo de Pontuação.
Conecte a saída inferior direita de Dados divididos à entrada superior direita do item Modelo de pontuação.
Na lista de itens Experimentar no painel à esquerda, expanda Avaliação do Aprendizado> de Máquina e arraste o item Avaliar Modelo para a tela.
Conecte a saída do Modelo de Pontuação à entrada superior esquerda do Modelo de Avaliação.
Você construiu seu primeiro experimento de aprendizado de máquina. Agora você pode salvar e executar o experimento. No menu na parte inferior da página, clique no botão Salvar para salvar seu experimento e, em seguida, clique em Executar para iniciar o experimento.
Você pode ver o status do experimento no canto superior direito da tela. Aguarde alguns instantes até que a experiência termine.
Se você tiver um grande conjunto de dados (do mundo real), é provável que o experimento leve horas para ser executado.
Clique com o botão direito do mouse no item Avaliar Modelo na tela e, no menu de contexto, passe o mouse sobre Resultados da Avaliação e selecione Visualizar.
Os resultados da avaliação serão exibidos mostrando os resultados previstos versus os resultados reais. Isso usa os 30% do conjunto de dados original, que foi dividido anteriormente, para avaliar o modelo. Você pode ver que os resultados não são ótimos, o ideal seria que o maior número em cada linha fosse o item destacado nas colunas.
Feche os resultados.
Para usar seu modelo de Machine Learning recém-treinado, você precisa expô-lo como um serviço Web. Para fazer isso, clique no item de menu Configurar serviço Web no menu na parte inferior da página e clique em Serviço Web preditivo.
Uma nova guia será criada e o modelo de trem será mesclado para criar o novo serviço Web.
No menu na parte inferior da página, clique em Guardar e, em seguida, clique em Executar. Você verá o status atualizado no canto superior direito da tela do experimento.
Quando terminar a execução, um botão Implantar Serviço Web aparecerá na parte inferior da página. Você está pronto para implantar o serviço Web. Clique em Implantar Serviço Web (Clássico) no menu na parte inferior da página.
Seu navegador pode solicitar a permissão de um pop-up, o que você deve permitir, embora talvez seja necessário pressionar Implantar Serviço Web novamente, se a página de implantação não for exibida.
Uma vez que o experimento tenha sido criado, você será redirecionado para uma página do painel onde sua chave de API será exibida. Copie-o para um bloco de notas no momento, você vai precisar dele em seu código muito em breve. Depois de anotar sua chave de API, clique no botão SOLICITAÇÃO/RESPOSTA na seção Ponto de extremidade padrão abaixo da chave.
Nota
Se você clicar em Testar nesta página, poderá inserir dados de entrada e visualizar a saída. Insira o dia e a hora. Deixe a entrada do produto em branco. Em seguida, clique no botão Confirmar . A saída na parte inferior da página mostrará o JSON representando a probabilidade de cada produto ser a escolha.
Uma nova página da Web será aberta, exibindo as instruções e alguns exemplos sobre a estrutura de solicitação exigida pelo Estúdio de Aprendizado de Máquina (clássico). Copie o URI de solicitação exibido nesta página para o bloco de notas.
Agora você criou um sistema de aprendizado de máquina que fornece o produto mais provável de ser vendido com base em dados históricos de compras, correlacionados com a hora do dia e o dia do ano.
Para chamar o serviço Web, você precisará da URL do ponto de extremidade do serviço e de uma chave de API para o serviço. Clique na guia Consumir , no menu superior.
A página Informações de Consumo exibirá as informações necessárias para chamar o serviço Web a partir do seu código. Faça uma cópia da Chave Primária e da URL de Solicitação-Resposta . Você vai precisar deles no próximo Capítulo.
Capítulo 5 - Configurando o Projeto Unity
Configure e teste o seu Auricular Imersivo de Realidade Mista.
Nota
Você não precisará de controladores de movimento para este curso. Se você precisar de suporte para configurar o fone de ouvido imersivo, clique AQUI.
Abra a Unidade e crie um novo Projeto Unity chamado MR_MachineLearning. Verifique se o tipo de projeto está definido como 3D.
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, na nova janela, navegue até Ferramentas Externas. Altere o Editor de Scripts Externo para Visual Studio 2017. Feche a janela Preferências .
Em seguida, vá para Configurações de compilação de arquivos>e mude a plataforma para a Plataforma Universal do Windows, clicando no botão Alternar plataforma.
Certifique-se também de que:
Dispositivo de destino está definido como Qualquer dispositivo.
Para o Microsoft HoloLens, defina Target Device como HoloLens.
Build Type está definido como D3D.
O SDK está definido como Instalado mais recente.
Versão do Visual Studio está definida como Mais recente instalado.
Build and Run é definido como Máquina Local.
Não se preocupe em configurar Cenas agora, pois elas são fornecidas posteriormente.
As configurações restantes devem ser deixadas como padrão por enquanto.
Na janela Configurações de compilação, clique no botão Configurações do player, isso abrirá o painel relacionado no espaço onde o inspetor está localizado.
Neste painel, algumas configurações precisam ser verificadas:
Na guia Outras configurações:
A versão do Scripting Runtime deve ser experimental (equivalente ao .NET 4.6)
O back-end de scripts deve ser .NET
O nível de compatibilidade da API deve ser .NET 4.6
Na guia Configurações de publicação , em Recursos, verifique:
InternetClient
Mais abaixo no painel, em Configurações XR (encontradas abaixo de Configurações de publicação), marque Realidade Virtual Suportada, verifique se o SDK de Realidade Mista do Windows foi adicionado
De volta às configurações de compilação, o Unity C# Projects não está mais acinzentado, marque a caixa de seleção ao lado disso.
Feche a janela Configurações de compilação.
Salve seu projeto (FILE > SAVE PROJECT).
Capítulo 6 - Importando o pacote MLProducts Unity
Para este curso, você precisará baixar um pacote de ativos Unity chamado Azure-MR-307.unitypackage. Este pacote vem completo com uma cena, com todos os objetos pré-construídos, para que você possa se concentrar em fazer tudo funcionar. O script ShelfKeeper é fornecido, embora contenha apenas as variáveis públicas, para fins de estrutura de configuração de cena. Você precisará fazer todas as outras seções.
Para importar este pacote:
Com o painel Unity à sua frente, clique em Ativos no menu na parte superior da tela e, em seguida, clique em Importar pacote, pacote personalizado.
Use o seletor de arquivos para selecionar o pacote Azure-MR-307.unitypackage e clique em Abrir.
Uma lista de componentes para este ativo será exibida para você. Confirme a importação clicando em Importar.
Quando terminar de importar, você notará que algumas novas pastas apareceram no seu Painel de Projeto Unity. Esses são os modelos 3D e os respetivos materiais que fazem parte da cena pré-fabricada em que você vai trabalhar. Você escreverá a maior parte do código neste curso.
Dentro da pasta Painel do Projeto , clique na pasta Cenas e clique duas vezes na cena dentro (chamada MR_MachineLearningScene). A cena será aberta (veja imagem abaixo). Se os diamantes vermelhos estiverem faltando, basta clicar no botão Gizmos, no canto superior direito do Painel de Jogo.
Capítulo 7 - Verificando as DLLs no Unity
Para aproveitar o uso de bibliotecas JSON (usadas para serialização e desserialização), uma DLL Newtonsoft foi implementada com o pacote que você trouxe. A biblioteca deve ter a configuração correta, embora valha a pena verificar (particularmente se você estiver tendo problemas com o código não funcionando).
Para tal:
Clique com o botão esquerdo no arquivo Newtonsoft dentro da pasta Plugins e olhe para o painel Inspetor. Certifique-se de que Any Platform está marcada. Vá para a guia UWP e também verifique se Não processar está marcado.
Capítulo 8 - Criar a classe ShelfKeeper
A classe ShelfKeeper hospeda métodos que controlam a interface do usuário e os produtos gerados na cena.
Como parte do pacote importado, você terá recebido essa classe, embora esteja incompleta. Chegou o momento de completar essa aula:
Clique duas vezes no script ShelfKeeper, dentro da pasta Scripts, para abri-lo com o Visual Studio 2017.
Substitua todo o código existente no script pelo código a seguir, que define a hora e a data e tem um método para mostrar um produto.
using UnityEngine; public class ShelfKeeper : MonoBehaviour { /// <summary> /// Provides this class Singleton-like behavior /// </summary> public static ShelfKeeper instance; /// <summary> /// Unity Inspector accessible Reference to the Text Mesh object needed for data /// </summary> public TextMesh dateText; /// <summary> /// Unity Inspector accessible Reference to the Text Mesh object needed for time /// </summary> public TextMesh timeText; /// <summary> /// Provides references to the spawn locations for the products prefabs /// </summary> public Transform[] spawnPoint; private void Awake() { instance = this; } /// <summary> /// Set the text of the date in the scene /// </summary> public void SetDate(string day, string month) { dateText.text = day + " " + month; } /// <summary> /// Set the text of the time in the scene /// </summary> public void SetTime(string hour) { timeText.text = hour + ":00"; } /// <summary> /// Spawn a product on the shelf by providing the name and selling grade /// </summary> /// <param name="name"></param> /// <param name="sellingGrade">0 being the best seller</param> public void SpawnProduct(string name, int sellingGrade) { Instantiate(Resources.Load(name), spawnPoint[sellingGrade].transform.position, spawnPoint[sellingGrade].transform.rotation); } }Certifique-se de salvar suas alterações no Visual Studio antes de retornar ao Unity.
De volta ao Editor Unity, verifique se a classe ShelfKeeper se parece com a abaixo:
Importante
Se o script não tiver os destinos de referência (ou seja , Data (Malha de Texto)), basta arrastar os objetos correspondentes do Painel de Hierarquia para os campos de destino. Veja abaixo a explicação, se necessário:
Abra a matriz Spawn Point dentro do script do componente ShelfKeeper clicando com o botão esquerdo do mouse. Será exibida uma subseção chamada Tamanho, que indica o tamanho da matriz. Digite 3 na caixa de texto ao lado de Tamanho e pressione Enter, e três slots serão criados abaixo.
Dentro da hierarquia, expanda o objeto Time Display (clicando com o botão esquerdo na seta ao lado dele). Em seguida, clique na câmera principal de dentro da hierarquia, para que o inspetor mostre suas informações.
Selecione a câmera principal no painel Hierarquia. Arraste os objetos Data e Hora do Painel Hierarquia para os slots Texto de Data e Hora dentro do Inspetor da Câmera Principal no componente ShelfKeeper.
Arraste os Pontos de Desova do Painel de Hierarquia (abaixo do objeto Prateleira) para os destinos de referência de 3 Elementos abaixo da matriz de Pontos de Desova, conforme mostrado na imagem.
Capítulo 9 - Criar a classe ProductPrediction
A próxima classe que você vai criar é a classe ProductPrediction .
Esta classe é responsável por:
Consultando a instância do Serviço de Machine Learning, fornecendo a data e hora atuais.
Desserialização da resposta JSON em dados utilizáveis.
Interpretação dos dados, recuperação dos 3 produtos recomendados.
Chamando os métodos da classe ShelfKeeper para exibir os dados na Cena.
Para criar esta classe:
Vá para a pasta Scripts , no Painel do Projeto.
Clique com o botão direito do mouse dentro da pasta, Create>C# Script. Chame o script ProductPrediction.
Clique duas vezes no novo script ProductPrediction para abri-lo com o Visual Studio 2017.
Se a caixa de diálogo Modificação de arquivo detetada aparecer, clique em *Recarregar solução.
Adicione os seguintes namespaces à parte superior da classe ProductPrediction:
using System; using System.Collections.Generic; using UnityEngine; using System.Linq; using Newtonsoft.Json; using UnityEngine.Networking; using System.Runtime.Serialization; using System.Collections;Dentro da classe ProductPrediction , insira os dois objetos a seguir, que são compostos por várias classes aninhadas. Essas classes são usadas para serializar e desserializar o JSON para o Serviço de Aprendizado de Máquina.
/// <summary> /// This object represents the Prediction request /// It host the day of the year and hour of the day /// The product must be left blank when serialising /// </summary> public class RootObject { public Inputs Inputs { get; set; } } public class Inputs { public Input1 input1 { get; set; } } public class Input1 { public List<string> ColumnNames { get; set; } public List<List<string>> Values { get; set; } }/// <summary> /// This object containing the deserialised Prediction result /// It host the list of the products /// and the likelihood of them being sold at current date and time /// </summary> public class Prediction { public Results Results { get; set; } } public class Results { public Output1 output1; } public class Output1 { public string type; public Value value; } public class Value { public List<string> ColumnNames { get; set; } public List<List<string>> Values { get; set; } }Em seguida, adicione as seguintes variáveis acima do código anterior (para que o código relacionado a JSON esteja na parte inferior do script, abaixo de todos os outros códigos e fora do caminho):
/// <summary> /// The 'Primary Key' from your Machine Learning Portal /// </summary> private string authKey = "-- Insert your service authentication key here --"; /// <summary> /// The 'Request-Response' Service Endpoint from your Machine Learning Portal /// </summary> private string serviceEndpoint = "-- Insert your service endpoint here --"; /// <summary> /// The Hour as set in Windows /// </summary> private string thisHour; /// <summary> /// The Day, as set in Windows /// </summary> private string thisDay; /// <summary> /// The Month, as set in Windows /// </summary> private string thisMonth; /// <summary> /// The Numeric Day from current Date Conversion /// </summary> private string dayOfTheYear; /// <summary> /// Dictionary for holding the first (or default) provided prediction /// from the Machine Learning Experiment /// </summary> private Dictionary<string, string> predictionDictionary; /// <summary> /// List for holding product prediction with name and scores /// </summary> private List<KeyValuePair<string, double>> keyValueList;Importante
Certifique-se de inserir a chave primária e o ponto de extremidade de solicitação-resposta, do Portal de Aprendizado de Máquina, nas variáveis aqui. As imagens abaixo mostram de onde você teria tirado a chave e o ponto final.
Insira esse código no método Start( ). O método Start() é chamado quando a classe inicializa:
void Start() { // Call to get the current date and time as set in Windows GetTodayDateAndTime(); // Call to set the HOUR in the UI ShelfKeeper.instance.SetTime(thisHour); // Call to set the DATE in the UI ShelfKeeper.instance.SetDate(thisDay, thisMonth); // Run the method to Get Predication from Azure Machine Learning StartCoroutine(GetPrediction(thisHour, dayOfTheYear)); }A seguir está o método que coleta a data e a hora do Windows e as converte em um formato que nosso experimento de aprendizado de máquina pode usar para comparar com os dados armazenados na tabela.
/// <summary> /// Get current date and hour /// </summary> private void GetTodayDateAndTime() { // Get today date and time DateTime todayDate = DateTime.Now; // Extrapolate the HOUR thisHour = todayDate.Hour.ToString(); // Extrapolate the DATE thisDay = todayDate.Day.ToString(); thisMonth = todayDate.ToString("MMM"); // Extrapolate the day of the year dayOfTheYear = todayDate.DayOfYear.ToString(); }Você pode excluir o método Update(), pois essa classe não o usará.
Adicione o seguinte método que comunicará a data e hora atuais ao ponto de extremidade do Machine Learning e receberá uma resposta no formato JSON.
private IEnumerator GetPrediction(string timeOfDay, string dayOfYear) { // Populate the request object // Using current day of the year and hour of the day RootObject ro = new RootObject { Inputs = new Inputs { input1 = new Input1 { ColumnNames = new List<string> { "day", "hour", "product" }, Values = new List<List<string>>() } } }; List<string> l = new List<string> { dayOfYear, timeOfDay, "" }; ro.Inputs.input1.Values.Add(l); Debug.LogFormat("Score request built"); // Serialize the request string json = JsonConvert.SerializeObject(ro); using (UnityWebRequest www = UnityWebRequest.Post(serviceEndpoint, "POST")) { byte[] jsonToSend = new System.Text.UTF8Encoding().GetBytes(json); www.uploadHandler = new UploadHandlerRaw(jsonToSend); www.downloadHandler = new DownloadHandlerBuffer(); www.SetRequestHeader("Authorization", "Bearer " + authKey); www.SetRequestHeader("Content-Type", "application/json"); www.SetRequestHeader("Accept", "application/json"); yield return www.SendWebRequest(); string response = www.downloadHandler.text; // Deserialize the response DataContractSerializer serializer; serializer = new DataContractSerializer(typeof(string)); DeserialiseJsonResponse(response); } }Adicione o seguinte método, que é responsável por desserializar a resposta JSON e comunicar o resultado da desserialização para a classe ShelfKeeper . Este resultado serão os nomes dos três itens previstos para vender mais na data e hora atuais. Insira o código abaixo na classe ProductPrediction , abaixo do método anterior.
/// <summary> /// Deserialize the response received from the Machine Learning portal /// </summary> public void DeserialiseJsonResponse(string jsonResponse) { // Deserialize JSON Prediction prediction = JsonConvert.DeserializeObject<Prediction>(jsonResponse); predictionDictionary = new Dictionary<string, string>(); for (int i = 0; i < prediction.Results.output1.value.ColumnNames.Count; i++) { if (prediction.Results.output1.value.Values[0][i] != null) { predictionDictionary.Add(prediction.Results.output1.value.ColumnNames[i], prediction.Results.output1.value.Values[0][i]); } } keyValueList = new List<KeyValuePair<string, double>>(); // Strip all non-results, by adding only items of interest to the scoreList for (int i = 0; i < predictionDictionary.Count; i++) { KeyValuePair<string, string> pair = predictionDictionary.ElementAt(i); if (pair.Key.StartsWith("Scored Probabilities")) { // Parse string as double then simplify the string key so to only have the item name double scorefloat = 0f; double.TryParse(pair.Value, out scorefloat); string simplifiedName = pair.Key.Replace("\"", "").Replace("Scored Probabilities for Class", "").Trim(); keyValueList.Add(new KeyValuePair<string, double>(simplifiedName, scorefloat)); } } // Sort Predictions (results will be lowest to highest) keyValueList.Sort((x, y) => y.Value.CompareTo(x.Value)); // Spawn the top three items, from the keyValueList, which we have sorted for (int i = 0; i < 3; i++) { ShelfKeeper.instance.SpawnProduct(keyValueList[i].Key, i); } // Clear lists in case of reuse keyValueList.Clear(); predictionDictionary.Clear(); }Salve o Visual Studio e volte para Unity.
Arraste o script de classe ProductPrediction da pasta Script para o objeto Main Camera .
Salve sua cena e projeto Arquivo>Salvar cena/Arquivo>salvar projeto.
Capítulo 10 - Criar a solução UWP
Agora é hora de criar seu projeto como uma solução UWP, para que ele possa ser executado como um aplicativo autônomo.
Para construir:
Salve a cena atual clicando em Arquivo>salvar cenas.
Vá para Configurações de compilação de arquivo>
Marque a caixa chamada Unity C# Projects (isso é importante porque permitirá que você edite as classes após a conclusão da compilação).
Clique em Adicionar cenas abertas,
Clique em Compilar.
Ser-lhe-á pedido para selecionar a pasta onde pretende criar a Solução.
Crie uma pasta BUILDS e dentro dessa pasta crie outra pasta com um nome apropriado de sua escolha.
Clique na nova pasta e, em seguida, clique em Selecionar pasta para iniciar a compilação nesse local.
Assim que o Unity terminar de construir (pode levar algum tempo), ele abrirá uma janela do Explorador de Arquivos no local da sua compilação (verifique sua barra de tarefas, pois nem sempre ela aparecerá acima de suas janelas, mas notificará você sobre a adição de uma nova janela).
Capítulo 11 - Implantar seu aplicativo
Para implantar seu aplicativo:
Navegue até sua nova compilação Unity (a pasta App) e abra o arquivo de solução com o Visual Studio.
Com o Visual Studio aberto, você precisa Restaurar Pacotes NuGet, o que pode ser feito clicando com o botão direito do mouse em sua solução MachineLearningLab_Build, no Gerenciador de Soluções (encontrado à direita do Visual Studio) e, em seguida, clicando em Restaurar Pacotes NuGet:
Na Configuração da Solução, selecione Depurar.
Na Plataforma de Solução, selecione x86, Máquina Local.
Para o Microsoft HoloLens, você pode achar mais fácil definir isso como Máquina Remota, para que você não esteja preso ao seu computador. No entanto, você também precisará fazer o seguinte:
- Conheça o endereço IP do seu HoloLens, que pode ser encontrado nas Configurações > de Rede e Opções Avançadas de Wi-Fi > da Internet>, o IPv4 é o endereço que você deve usar.
- Verifique se o Modo de Desenvolvedor está Ativado, encontrado em Atualização de Configurações > e Segurança > para desenvolvedores.
Vá para o menu Build e clique em Deploy Solution para fazer sideload do aplicativo para o seu PC.
Seu aplicativo agora deve aparecer na lista de aplicativos instalados, prontos para serem iniciados.
Ao executar o aplicativo de Realidade Mista, você verá o banco que foi configurado em sua cena Unity e, a partir da inicialização, os dados configurados no Azure serão buscados. Os dados serão desserializados em seu aplicativo, e os três principais resultados para sua data e hora atuais serão fornecidos visualmente, como três modelos no banco.
A sua aplicação de Machine Learning concluída
Parabéns, você criou um aplicativo de realidade mista que aproveita o Aprendizado de Máquina do Azure para fazer previsões de dados e exibi-los em sua cena.
Exercício
Exercício 1
Experimente a ordem de classificação do seu aplicativo e faça com que as três previsões inferiores apareçam na prateleira, pois esses dados também seriam potencialmente úteis.
Exercício 2
Usando as Tabelas do Azure, preencha uma nova tabela com informações meteorológicas e crie um novo experimento usando os dados.