HoloLens (prima generazione) e Azure 307: Machine Learning

Articolo
03/21/2023

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.

prodotto finale -start

In questo corso si apprenderà come aggiungere funzionalità di Machine Learning (ML) a un'applicazione di realtà mista usando Azure Machine Learning Studio (versione classica).

Azure Machine Learning Studio (versione classica) è un servizio Microsoft, che offre agli sviluppatori un numero elevato di algoritmi di Machine Learning, che possono essere utili per l'input, l'output, la preparazione e la visualizzazione dei dati. Da questi componenti è quindi possibile sviluppare un esperimento di analisi predittiva, eseguirne l'iterazione e usarlo per eseguire il training del modello. Dopo il training, è possibile rendere operativo il modello all'interno del cloud di Azure, in modo che possa quindi assegnare un punteggio ai nuovi dati. Per altre informazioni, visitare la pagina di Azure Machine Learning Studio (versione classica).

Dopo aver completato questo corso, si avrà un'applicazione visore VR immersive in realtà mista e si sarà appreso come eseguire le operazioni seguenti:

Fornire una tabella dei dati di vendita al portale di Azure Machine Learning Studio (versione classica) e progettare un algoritmo per stimare le vendite future degli articoli più diffusi.
Creare un progetto Unity, che può ricevere e interpretare i dati di stima dal servizio ML.
Visualizzare visivamente i dati del predicato all'interno del progetto Unity, fornendo gli articoli di vendita più diffusi, su uno scaffale.

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 compito di usare le conoscenze acquisite da questo corso per migliorare l'applicazione di realtà mista.

Questo corso è un'esercitazione autonoma, che non coinvolge direttamente altri lab Realtà mista.

Supporto di dispositivi

Corso	HoloLens	Visori VR immersive
MR e Azure 307: Machine Learning	✔️	✔

Nota

Anche se questo corso è incentrato principalmente su Windows Mixed Reality visori VR immersive, è anche possibile applicare ciò che si impara in questo corso per Microsoft HoloLens. Mentre si segue insieme al corso, verranno visualizzate note su tutte le modifiche che potrebbe essere necessario 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 stesura del documento (maggio 2018). Si è liberi di usare il software più recente, come elencato all'interno dell'articolo installare gli strumenti, anche se non si deve presupporre che le informazioni in questo corso corrisponderanno perfettamente a ciò che troverete 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 Mixed Reality per lo sviluppo di visori VR immersive
Windows 10 Fall Creators Update (o versione successiva) con la modalità sviluppatore abilitata
L'SDK di Windows 10 più recente
Unity 2017.4
Visual Studio 2017
Visore VR immersive Windows Mixed Reality o Microsoft HoloLens con la modalità sviluppatore abilitata
Accesso a Internet per la configurazione di Azure e il recupero dei dati di Machine Learning

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 di cartelle lunghi possono causare problemi in fase di compilazione).

Capitolo 1 - Configurazione dell'account di archiviazione di Azure

Per usare l'API Di Azure Translator, è 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 proctor di assistenza per configurare il nuovo account.
Dopo aver eseguito l'accesso, fare clic su Account di archiviazione nel menu a sinistra.

Nota

La parola Nuovo potrebbe essere stata sostituita con Crea una risorsa, nei portali più recenti.
Nella scheda Account di archiviazione fare clic su Aggiungi.
Nel pannello Crea account di archiviazione :
1. Inserire un nome per l'account, tenere presente che questo campo accetta solo numeri e lettere minuscole.
2. Per Modello di distribuzione selezionare Resource Manager.
3. Per Tipo di account selezionare Archiviazione (utilizzo generico v1).
4. Per Prestazioni selezionare Standard.
5. Per Replica selezionare Archiviazione con ridondanza geografica e accesso in lettura (RA-GRS).
6. Lasciare Il trasferimento sicuro obbligatorio come Disabilitato.
7. Selezionare una Sottoscrizione.
8. 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 lab, in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, vedere l'articolo sul gruppo di risorse.
9. Determinare la posizione 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.
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.

Capitolo 2 - Azure Machine Learning Studio (versione classica)

Per usare Azure Machine Learning, è necessario configurare un'istanza del servizio Machine Learning da rendere disponibile per l'applicazione.

Nel portale di Azure fare clic su Nuovo nell'angolo in alto a sinistra e cercare Area di lavoro di Machine Learning Studio, premere INVIO.
La nuova pagina fornirà una descrizione del servizio Area di lavoro di Machine Learning Studio . Nella parte inferiore sinistra di questa richiesta fare clic sul pulsante Crea per creare un'associazione con questo servizio.
Dopo aver fatto clic su Crea, verrà visualizzato un pannello in cui è necessario fornire alcuni dettagli sul nuovo servizio Machine Learning Studio:
1. Inserire il nome dell'area di lavoro desiderato per questa istanza del servizio.
2. Selezionare una Sottoscrizione.
3. 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 lab, in un gruppo di risorse comune.
  
  Per altre informazioni sui gruppi di risorse di Azure, vedere l'articolo sul gruppo di risorse.
4. Determinare la posizione 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. È consigliabile usare lo stesso gruppo di risorse usato per la creazione di Archiviazione di Azure nel capitolo precedente.
5. Per la sezione Account di archiviazione fare clic su Usa esistente, quindi scegliere il menu a discesa e quindi fare clic sull'account di archiviazione creato nell'ultimo capitolo.
6. Selezionare il piano tariffario dell'area di lavoro appropriato dal menu a discesa.
7. Nella sezione Piano di servizio Web fare clic su Creanuovo, quindi inserire un nome nel campo di testo.
8. Nella sezione Piano tariffario del piano di servizio Web selezionare il piano tariffario preferito. Un livello di test di sviluppo denominato DEVTEST Standard deve essere disponibile gratuitamente.
9. Sarà anche necessario verificare di aver compreso le condizioni e le condizioni applicate al servizio.
10. Fare clic su 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.
Nella pagina visualizzata, nella sezione Collegamenti aggiuntivi fare clic su Avvia Machine Learning Studio per indirizzare il browser al portale di Machine Learning Studio .
Usare il pulsante Accedi in alto a destra o al centro per accedere a Machine Learning Studio (versione classica).

Capitolo 3 - Machine Learning Studio (versione classica): Configurazione del set di dati

Uno dei modi in cui funzionano gli algoritmi di Machine Learning consiste nell'analizzare i dati esistenti e quindi tentare di stimare i risultati futuri in base al set di dati esistente. Ciò significa in genere che i dati più esistenti sono disponibili, migliore sarà l'algoritmo a prevedere i risultati futuri.

Per questo corso viene fornita una tabella di esempio denominata ProductsTableCSV e può essere scaricata qui.

Importante

Il file precedente .zip contiene sia ProductsTableCSV che unitypackage, che sarà necessario nel capitolo 6. Questo pacchetto viene fornito anche all'interno di tale capitolo, anche se separato dal file csv.

Questo set di dati di esempio contiene un record degli oggetti più venduti ogni ora di ogni giorno dell'anno 2017.

Screenshot della finestra di Microsoft Excel, che mostra un set di dati di esempio di oggetti più venduti ogni ora di ogni giorno nell'anno 2017.

Ad esempio, il giorno 1 del 2017, alle 13 (ora 13), l'articolo più venduto era sale e pepe.

Questa tabella di esempio contiene 9998 voci.

Tornare al portale di Machine Learning Studio (versione classica) e aggiungere questa tabella come set di dati per ml. A tale scopo, fare clic sul pulsante + Nuovo nell'angolo inferiore sinistro della schermata.
Una sezione verrà visualizzata dal basso e all'interno del pannello di spostamento a sinistra. Fare clic su Set di dati, quindi a destra di tale file, Da file locale.
Caricare il nuovo set di dati seguendo questa procedura:
1. Verrà visualizzata la finestra di caricamento, in cui è possibile esplorare il disco rigido per il nuovo set di dati.
2. Dopo aver selezionato e tornare nella finestra di caricamento, lasciare deselezionata la casella di controllo.
3. Nel campo di testo seguente immettere ProductsTableCSV.csv come nome per il set di dati (anche se deve essere aggiunto automaticamente).
4. Usando il menu a discesa per Tipo, selezionare File CSV generico con un'intestazione (.csv).
5. Premere il segno di spunta nella parte inferiore destra della finestra di caricamento e il set di dati verrà caricato.

Capitolo 4 - Machine Learning Studio (versione classica): Esperimento

Prima di poter compilare il sistema di Machine Learning, è necessario creare un esperimento per convalidare la teoria dei dati. Con i risultati, si saprà se sono necessari più dati o se non esiste alcuna correlazione tra i dati e un possibile risultato.

Per iniziare a creare un esperimento:

Fare di nuovo clic sul pulsante + Nuovo nella parte inferiore sinistra della pagina, quindi fare clic suEsperimento vuoto esperimento>.
Verrà visualizzata una nuova pagina con un esperimento vuoto:
Nel pannello a sinistra espandere Set di dati salvati My Datasets> e trascinare ProductsTableCSV su nell'area di disegno dell'esperimento.
Nel pannello a sinistra espandere Esempio di trasformazione> datie Divisione. Trascinare quindi l'elemento Split Data in nell'area di disegno dell'esperimento. L'elemento Split Data suddividerà il set di dati in due parti. Una parte verrà usata per il training dell'algoritmo di Machine Learning. La seconda parte verrà usata per valutare l'accuratezza dell'algoritmo generato.
Nel pannello di destra (mentre l'elemento Split Data nell'area di disegno è selezionato), modificare la frazione di righe nel primo set di dati di output in 0,7. I dati verranno suddivisi in due parti, la prima parte sarà il 70% dei dati e la seconda sarà il restante 30%. Per assicurarsi che i dati vengano suddivisi in modo casuale, assicurarsi che la casella di controllo Suddivisione casuale rimanga selezionata.
Trascinare una connessione dalla base dell'elemento ProductsTableCSV nell'area di disegno nella parte superiore dell'elemento Split Data .Drag a connection from the base of the ProductsTableCSV item on the canvas to the top of the Split Data item. Verranno connessi gli elementi e l'output del set di dati ProductsTableCSV (i dati) all'input Split Data (Split Data).
Nel pannello Esperimenti a sinistra espandere Machine LearningTrain (Training machine learning>). Trascinare l'elemento Train Model (Esegui training modello ) nell'area di disegno Experiment (Esperimento). L'area di disegno dovrebbe essere identica a quella riportata di seguito.
Nella parte inferiore sinistra dell'elemento Split Data trascinare una connessione in alto a destra dell'elemento Train Model ( Esegui training modello ). La prima divisione del 70% dal set di dati verrà usata dal modello train per eseguire il training dell'algoritmo.
Selezionare l'elemento Train Model (Esegui training modello ) nell'area di disegno e nel pannello Proprietà (sul lato destro della finestra del browser) fare clic sul pulsante Launch column selector (Avvia selettore di colonna ).
Nella casella di testo digitare product e quindi premere INVIO, il prodotto verrà impostato come colonna per eseguire il training delle stime. A questo punto, fare clic sul segno di spunta nell'angolo inferiore destro per chiudere la finestra di dialogo di selezione.
Si eseguirà il training di un algoritmo Multiclass Logistic Regression per stimare il prodotto più venduto in base all'ora del giorno e alla data. È oltre l'ambito di questo documento per spiegare i dettagli dei diversi algoritmi forniti dal studio di Azure Machine Learning, tuttavia, è possibile ottenere altre informazioni dal foglio informativo sugli algoritmi di Machine Learning
Nel pannello degli elementi dell'esperimento a sinistra espandere Machine Learning>Initialize Model Classification (Inizializza classificazione modello>) e trascinare l'elemento Multiclass Logistic Regression (Regressione logistica multiclasse) nell'area di disegno dell'esperimento.
Connettere l'output, dalla parte inferiore della regressione logistica multiclasse, all'input in alto a sinistra dell'elemento Train Model (Training modello ).
Nell'elenco di elementi dell'esperimento nel pannello a sinistra espanderePunteggio di Machine Learning> e trascinare l'elemento Score Model (Punteggio modello) nell'area di disegno.
Connettere l'output, dalla parte inferiore del modello di training, all'input in alto a sinistra del modello di punteggio.
Connettere l'output in basso a destra da Split Data (Split Data) all'input in alto a destra dell'elemento Score Model (Punteggio modello ).
Nell'elenco di elementi Esperimento nel pannello a sinistra espandere Machine Learning>Evaluate e trascinare l'elemento Evaluate Model (Valuta modello ) nell'area di disegno.
Connettere l'output dal modello score all'input in alto a sinistra del modello di valutazione.
È stato creato il primo esperimento di Machine Learning. È ora possibile salvare ed eseguire l'esperimento. Nel menu nella parte inferiore della pagina fare clic sul pulsante Salva per salvare l'esperimento e quindi fare clic su Esegui per avviare l'esperimento.
È possibile visualizzare lo stato dell'esperimento in alto a destra nell'area di disegno. Attendere alcuni istanti per il completamento dell'esperimento.

Se si dispone di un set di dati grande (reale), è probabile che l'esperimento possa richiedere ore per l'esecuzione.
Fare clic con il pulsante destro del mouse sull'elemento Evaluate Model nell'area di disegno e scegliere Visualizza dal menu di scelta rapida.
I risultati della valutazione verranno visualizzati con i risultati stimati rispetto ai risultati effettivi. In questo modo viene usato il 30% del set di dati originale, suddiviso in precedenza, per la valutazione del modello. È possibile notare che i risultati non sono ottimali, idealmente si avrà il numero più alto in ogni riga sia l'elemento evidenziato nelle colonne.
Chiudere i risultati.
Per usare il modello di Machine Learning appena sottoposto a training, è necessario esporlo come servizio Web. A tale scopo, fare clic sulla voce di menu Configura servizio Web nel menu nella parte inferiore della pagina e fare clic su Servizio Web predittivo.
Verrà creata una nuova scheda e il modello di training verrà unito per creare il nuovo servizio Web.
Nel menu nella parte inferiore della pagina fare clic su Salva, quindi fare clic su Esegui. Lo stato verrà aggiornato nell'angolo superiore destro dell'area di disegno dell'esperimento.
Al termine dell'esecuzione, nella parte inferiore della pagina verrà visualizzato un pulsante Distribuisci servizio Web . Si è pronti per distribuire il servizio Web. Fare clic su Distribuisci servizio Web (versione classica) nel menu nella parte inferiore della pagina.

Il browser potrebbe richiedere di consentire un popup, che dovrebbe essere consentito, anche se potrebbe essere necessario premere di nuovo Distribuisci servizio Web , se la pagina di distribuzione non viene visualizzata.
Dopo aver creato l'esperimento, si verrà reindirizzati a una pagina dashboard in cui verrà visualizzata la chiave API . Copiarlo in un Blocco note per il momento, sarà necessario nel codice molto presto. Dopo aver annotato la chiave API, fare clic sul pulsante REQUEST/RESPONSE nella sezione Endpoint predefinito sotto la chiave.

Nota

Se si fa clic su Test in questa pagina, sarà possibile immettere i dati di input e visualizzare l'output. Immettere il giorno e l'ora. Lasciare vuota la voce del prodotto . Fare quindi clic sul pulsante Conferma . L'output nella parte inferiore della pagina mostrerà il codice JSON che rappresenta la probabilità che ogni prodotto sia la scelta.
Verrà aperta una nuova pagina Web, visualizzando le istruzioni e alcuni esempi sulla struttura richiesta da Machine Learning Studio (versione classica). Copiare l'URI della richiesta visualizzato in questa pagina nel Blocco note.

È stato creato un sistema di Machine Learning che fornisce il prodotto più probabile da vendere in base ai dati di acquisto cronologici, correlati all'ora del giorno e del giorno dell'anno.

Per chiamare il servizio Web, è necessario l'URL per l'endpoint del servizio e una chiave API per il servizio. Fare clic sulla scheda Consume (Consuma ) dal menu in alto.

Nella pagina Informazioni sul consumo verranno visualizzate le informazioni necessarie per chiamare il servizio Web dal codice. Copiare la chiave primaria e l'URL request-response . Questi saranno necessari nel capitolo successivo.

Capitolo 5 - Configurazione del progetto Unity

Configurare e testare il Realtà mista visore VR immersive.

Nota

Per questo corso non saranno necessari controller di movimento. Se è necessario supportare la configurazione del visore VR immersive, fare clic qui.

Aprire Unity e creare un nuovo progetto Unity denominato MR_MachineLearning. Assicurarsi che il tipo di progetto sia impostato su 3D.
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 aImpostazioni compilazionefile> e impostare la piattaforma su piattaforma UWP (Universal Windows Platform), facendo clic sul pulsante Cambia piattaforma.
Assicurarsi anche che:
1. Il dispositivo di destinazione è impostato su Qualsiasi dispositivo.
  
  Per il Microsoft HoloLens, impostare Dispositivo di destinazione su HoloLens.
2. Il tipo di compilazione è impostato su D3D.
3. L'SDK è impostato su Più recente installato.
4. La versione di Visual Studio è impostata su Più recente installata.
5. Compilazione ed esecuzione è impostata su Computer locale.
6. Non preoccuparti di configurare le scene in questo momento, perché queste vengono fornite in un secondo momento.
7. Per il momento le impostazioni rimanenti devono essere lasciate come predefinite.
Nella finestra Build Settings (Impostazioni compilazione) fare clic sul pulsante Player Settings (Impostazioni lettore ) per aprire il pannello correlato nello spazio in cui si trova il controllo .
In questo pannello è necessario verificare alcune impostazioni:
1. Nella scheda Altre impostazioni :
  1. La versione del runtimedi scripting deve essere sperimentale (equivalente a .NET 4.6)
  2. Il back-end di scripting deve essere .NET
  3. Il livello di compatibilità dell'API deve essere .NET 4.6
2. Nella scheda Impostazioni di pubblicazione , in Funzionalità, selezionare:
  - InternetClient
3. Più avanti nel pannello, in Impostazioni XR (disponibili sotto Impostazioni di pubblicazione), selezionare Realtà virtuale supportata, assicurarsi che Windows Mixed Reality SDK sia stato aggiunto
In Build SettingsUnity C# Projects (Impostazioni di compilazione) I progetti C# non sono più disattivati; selezionare la casella di controllo accanto a questa.
Chiudere la finestra Build Settings (Impostazioni di compilazione).
Salvare il progetto (FILE > SAVE PROJECT).

Capitolo 6 - Importazione del pacchetto Unity MLProducts

Per questo corso, sarà necessario scaricare un pacchetto di asset unity denominato Azure-MR-307.unitypackage. Questo pacchetto è completo di una scena, con tutti gli oggetti in tale predefinita, in modo da potersi concentrare su come lavorare. Lo script ShelfKeeper viene fornito, anche se contiene solo le variabili pubbliche, allo scopo della struttura di configurazione della scena. Sarà necessario eseguire tutte le altre sezioni.

Per importare questo pacchetto:

Con il dashboard di Unity davanti a te, fai clic su Asset nel menu nella parte superiore della schermata, quindi fai clic su Importa pacchetto, pacchetto personalizzato.
Usare la selezione file per selezionare il pacchetto Azure-MR-307.unitypackage e fare clic su Apri.
Verrà visualizzato un elenco di componenti per questo asset. Confermare l'importazione facendo clic su Importa.
Al termine dell'importazione, si noterà che alcune nuove cartelle sono state visualizzate nel pannello del progetto Unity. Questi sono i modelli 3D e i rispettivi materiali che fanno parte della scena pre-made su cui lavorerai. In questo corso verrà scritta la maggior parte del codice.
Nella cartella Pannello progetto fare clic sulla cartella Scene e fare doppio clic sulla scena all'interno (denominata MR_MachineLearningScene). La scena verrà aperta (vedere l'immagine seguente). Se mancano i diamanti rossi, è sufficiente fare clic sul pulsante Gizmos , in alto a destra nel pannello del gioco.

Capitolo 7 - Controllo delle DLL in Unity

Per sfruttare l'uso delle librerie JSON (usate per la serializzazione e la deserializzazione), è stata implementata una DLL Newtonsoft con il pacchetto immesso. La libreria deve avere la configurazione corretta, anche se vale la pena verificare (in particolare se si verificano problemi con il codice che non funziona).

A tale scopo, procedere nel seguente modo:

Fare clic con il pulsante sinistro del mouse sul file Newtonsoft all'interno della cartella Plugins e osservare il pannello Inspector (Controllo). Assicurarsi che qualsiasi piattaforma sia selezionata. Passare alla scheda UWP e assicurarsi anche che Non elaborare sia selezionata.

Capitolo 8 - Creare la classe ShelfKeeper

La classe ShelfKeeper ospita metodi che controllano l'interfaccia utente e i prodotti generati nella scena.

Come parte del pacchetto importato, questa classe sarà stata assegnata, anche se è incompleta. È ora il momento di completare la classe:

Fare doppio clic sullo script ShelfKeeper , all'interno della cartella Scripts , per aprirlo con Visual Studio 2017.

Sostituire tutto il codice esistente nello script con il codice seguente, che imposta l'ora e la data e ha un metodo per visualizzare un prodotto.

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

Assicurarsi di salvare le modifiche in Visual Studio prima di tornare a Unity.
Tornare all'editor di Unity e verificare che la classe ShelfKeeper sia simile alla seguente:
Importante

Se lo script non ha le destinazioni di riferimento ,ad esempio Data (Mesh di testo), trascinare semplicemente gli oggetti corrispondenti dal Pannello gerarchia nei campi di destinazione. Vedere di seguito per una spiegazione, se necessario:
1. Aprire la matrice Spawn Point nello script del componente ShelfKeeper facendo clic con il pulsante sinistro del mouse. Verrà visualizzata una sezione secondaria denominata Size, che indica le dimensioni della matrice. Digitare 3 nella casella di testo accanto a Dimensioni e premere INVIO e tre slot verranno creati sotto.
2. All'interno della gerarchia espandere l'oggetto Visualizzazione ora facendo clic con il pulsante sinistro della freccia accanto. Fare quindi clic sulla fotocamera principale dall'interno della gerarchia, in modo che il controllo mostri le informazioni.
3. Selezionare la fotocamera principale nel pannello Gerarchia. Trascinare gli oggetti Data e ora dal pannello Gerarchia negli slot di testo di data e ora all'interno del controllo della fotocamera principale nel componente ShelfKeeper .
4. Trascinare Spawn Points dal pannello gerarchia (sotto l'oggetto Shelf) nelle destinazioni di riferimentoelemento 3 sotto la matrice Spawn Point, come illustrato nell'immagine.

Capitolo 9 - Creare la classe ProductPrediction

La classe successiva che si intende creare è la classe ProductPrediction .

Questa classe è responsabile di:

Esecuzione di query sull'istanza del servizio Machine Learning , specificando la data e l'ora correnti.
Deserializzazione della risposta JSON in dati utilizzabili.
Interpretazione dei dati, recupero dei 3 prodotti consigliati.
Chiamata dei metodi della classe ShelfKeeper per visualizzare i dati nella scena.

Per creare questa classe:

Passare alla cartella Scripts nel Pannello del progetto.
Fare clic con il pulsante destro del mouse all'interno della cartella Crea>script C#. Chiamare lo script ProductPrediction.
Fare doppio clic sul nuovo script ProductPrediction per aprirlo con Visual Studio 2017.
Se viene visualizzata la finestra di dialogo Modifica file rilevata , fare clic su *Ricarica soluzione.

Aggiungere gli spazi dei nomi seguenti all'inizio della 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;

All'interno della classe ProductPrediction inserire i due oggetti seguenti costituiti da una serie di classi annidate. Queste classi vengono usate per serializzare e deserializzare il codice JSON per il servizio Machine Learning.

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

Aggiungere quindi le variabili seguenti sopra il codice precedente , in modo che il codice correlato a JSON si trova nella parte inferiore dello script, sotto tutti gli altri codice e fuori strada:

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

Assicurarsi di inserire la chiave primaria e l'endpoint di richiesta-risposta, dal portale di Machine Learning, nelle variabili qui. Le immagini seguenti mostrano da dove si avrebbe preso la chiave e l'endpoint.

Screenshot del Microsoft Azure Machine Learning Studio, che mostra il collegamento Richiesta risposta barra sotto una pagina della Guida P I.

Screenshot della pagina Request Response A P I Documentation ,che mostra l'opzione POST Request U R I evidenziata.

Inserire questo codice all'interno del metodo Start(). Il metodo Start() viene chiamato quando la classe inizializza:

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

Di seguito è riportato il metodo che raccoglie la data e l'ora da Windows e la converte in un formato che l'esperimento di Machine Learning può usare per confrontare i dati archiviati nella tabella.

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

È possibile eliminare il metodo Update() perché questa classe non lo userà.

Aggiungere il metodo seguente che comunicherà la data e l'ora correnti all'endpoint di Machine Learning e riceverà una risposta in 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);
        }
    }

Aggiungere il metodo seguente, responsabile della deserializzazione della risposta JSON e della comunicazione del risultato della deserializzazione alla classe ShelfKeeper . Questo risultato sarà costituito dai nomi dei tre articoli stimati per vendere al massimo alla data e all'ora correnti. Inserire il codice seguente nella classe ProductPrediction sotto il metodo precedente.

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

Salvare Visual Studio e tornare a Unity.
Trascinare lo script della classe ProductPrediction dalla cartella Script nell'oggetto Main Camera .
Salvare la scena e il progetto>Salva scena/File>Salva progetto.

Capitolo 10 - Creare la soluzione UWP

È ora possibile compilare il progetto come soluzione UWP, in modo che possa essere eseguito come applicazione autonoma.

Per compilare:

Salvare la scena corrente facendo clic su Salva>scene file.
Passare aImpostazioni di compilazionefile>
Selezionare la casella denominata Progetti C# unity . Questa operazione è importante perché consente di modificare le classi al termine della compilazione.
Fare clic su Aggiungi scene aperte,
Fare clic 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 a scelta.
Fare clic sulla nuova cartella e quindi su Seleziona cartella per avviare la compilazione in tale percorso.
Una volta completata la compilazione di Unity (potrebbe essere necessario del tempo), verrà aperta una finestra di Esplora file nella posizione della compilazione (controllare la barra delle applicazioni, perché potrebbe non essere sempre visualizzata sopra le finestre, ma invierà una notifica dell'aggiunta di una nuova finestra).

Capitolo 11 - Distribuire l'applicazione

Per distribuire l'applicazione:

Passare alla nuova compilazione di Unity (cartella App ) e aprire il file della soluzione con Visual Studio.
Con Visual Studio aperto, è necessario ripristinare i pacchetti NuGet, che possono essere eseguiti facendo clic con il pulsante destro del mouse sulla soluzione MachineLearningLab_Build, dal Esplora soluzioni (a destra di Visual Studio) e quindi scegliendo Ripristina pacchetti NuGet:
In Configurazione soluzione selezionare Debug.
Nella piattaforma della soluzione selezionare x86, Computer locale.
Per la Microsoft HoloLens, è possibile che sia 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 del dispositivo HoloLens, disponibile all'interno di Impostazioni > Rete & Internet > Wi-Fi > Opzioni avanzate. IPv4 è l'indirizzo da usare.
- Verificare che la modalità sviluppatore sia attivata; disponibile in Impostazioni > Aggiornamento & sicurezza > per gli sviluppatori.
Passare al menu Compila e fare clic su Distribuisci soluzione per trasferire localmente l'applicazione nel PC.
L'app dovrebbe ora essere visualizzata nell'elenco delle app installate, pronto per l'avvio.

Quando si esegue l'applicazione Realtà mista, verrà visualizzata la panchina configurata nella scena unity e, dall'inizializzazione, i dati configurati in Azure verranno recuperati. I dati verranno deserializzati all'interno dell'applicazione e i tre risultati principali per la data e l'ora correnti verranno forniti visivamente, come tre modelli sulla panchina.

Applicazione Machine Learning completata

È stata creata un'app di realtà mista che sfrutta Azure Machine Learning per eseguire stime dei dati e visualizzarla nella scena.

Screenshot della finestra di Microsoft Visual Studio, che mostra uno scaffale con tre oggetti e una scheda con il testo 15 ore 23 febbraio.

Esercizio

Esercizio 1

Sperimentare l'ordinamento dell'applicazione e visualizzare le tre stime inferiori sullo scaffale, perché questi dati potrebbero essere utili anche.

Esercizio 2

L'uso di tabelle di Azure popola una nuova tabella con le informazioni meteo e crea un nuovo esperimento usando i dati.

Share via

HoloLens (prima generazione) e Azure 307: Machine Learning

Supporto di dispositivi

Prerequisiti

Prima di iniziare

Capitolo 1 - Configurazione dell'account di archiviazione di Azure

Capitolo 2 - Azure Machine Learning Studio (versione classica)

Capitolo 3 - Machine Learning Studio (versione classica): Configurazione del set di dati

Capitolo 4 - Machine Learning Studio (versione classica): Esperimento

Capitolo 5 - Configurazione del progetto Unity

Capitolo 6 - Importazione del pacchetto Unity MLProducts

Capitolo 7 - Controllo delle DLL in Unity

Capitolo 8 - Creare la classe ShelfKeeper

Capitolo 9 - Creare la classe ProductPrediction

Capitolo 10 - Creare la soluzione UWP

Capitolo 11 - Distribuire l'applicazione

Applicazione Machine Learning completata

Esercizio

Risorse aggiuntive