Esercitazione: Eseguire la classificazione delle immagini nella rete perimetrale con il Servizio visione artificiale personalizzato

Si applica a: IoT Edge 1.5 IoT Edge 1.4

Azure IoT Edge può rendere più efficienti le soluzioni IoT spostando i carichi di lavoro dal cloud alla rete perimetrale. Questa funzionalità è particolarmente utile per i servizi che elaborano grandi quantità di dati, come i modelli di visione artificiale. Visione personalizzata di Intelligenza artificiale di Azure consente di creare classificatori di immagini personalizzati e di distribuirli ai dispositivi come contenitori. Insieme, questi due servizi consentono di trovare informazioni dettagliate nelle immagini e nei flussi video senza dover prima trasferire tutti i dati in remoto. Il Servizio visione artificiale personalizzato fornisce un classificatore che confronta un'immagine con un modello con training per generare informazioni dettagliate.

In un dispositivo IoT Edge, ad esempio, il Servizio visione artificiale personalizzato potrebbe determinare se un'autostrada sta registrando un traffico superiore o inferiore al normale o se in un garage ci sono posti disponibili in una fila. Queste informazioni dettagliate possono essere condivise con un altro servizio in modo da intraprende l'azione appropriata.

In questa esercitazione apprenderai a:

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Prerequisiti

• Configurare l'ambiente per lo sviluppo di contenitori Linux completando l’Esercitazione: Sviluppare moduli IoT Edge con Visual Studio Code. Dopo aver completato l'esercitazione, è necessario avere i prerequisiti seguenti disponibili nell'ambiente di sviluppo:

  • Un hub IoT di livello Gratuito o Standard in Azure.
  • Un dispositivo che esegue Azure IoT Edge con contenitori Linux. È possibile usare le guide introduttive per configurare un dispositivo Linux o un dispositivo Windows.
  • Un registro contenitori, ad esempio Registro Azure Container.
  • Visual Studio Code configurato con le estensioni Azure IoT Edge e hub IoT di Azure. L'estensione Azure IoT Edge Tools per Visual Studio Code è in modalità manutenzione.
  • Scaricare e installare un sistema di gestione contenitori compatibile con Docker nel computer di sviluppo. Configurarlo per l'esecuzione di contenitori Linux.

• Per sviluppare un modulo IoT Edge con il servizio Visione personalizzata, installare i prerequisiti aggiuntivi seguenti nel computer di sviluppo:

  • Python
  • Git
  • Estensione Python per Visual Studio Code

Compilare un classificatore di immagini con il Servizio visione artificiale personalizzato

Per compilare un classificatore di immagini, occorre creare un progetto Visione personalizzata e fornire immagini per il training. Per altre informazioni sulla procedura da eseguire in questa sezione, vedere Come creare un classificatore con Visione personalizzata.

Dopo aver compilato ed eseguito il training del classificatore di immagini, è possibile esportarlo come contenitore Docker e distribuirlo in un dispositivo IoT Edge.

Crea un nuovo progetto

1. Nel Web browser passare alla pagina web Visione personalizzata.

2. Selezionare Sign in (Accedi) ed eseguire l'accesso con lo stesso account che si usa per accedere alle risorse di Azure.

3. Selezionare New project (Nuovo progetto).

4. Creare il progetto con i valori seguenti:

   Campo	Valore
   Nome	Specificare un nome per il progetto, ad esempio EdgeTreeClassifier.
   Descrizione	Descrizione facoltativa del progetto.
   Conto risorse	Selezionare uno dei gruppi di risorse di Azure che include una risorsa del servizio Visione personalizzata o crearne uno nuovo se non ne è stato ancora aggiunto uno.
   Project Types (Tipi di progetto)	Valutazione
   Classification Types (Tipi di classificazione)	Multiclass (single tag per image) (Multiclasse - singolo tag per immagine)
   Domini	General (compact) (Generale - compatto)
   Funzionalità di esportazione	Piattaforme di base (Tensorflow, CoreML, ONNX, ...)

5. Seleziona Crea progetto.

Caricare le immagini ed eseguire il training del classificatore

Per creare un classificatore di immagini sono necessari un set di immagini di training e un set di immagini di test.

1. Clonare o scaricare immagini di esempio dal repository Cognitive-CustomVision-Windows nel computer di sviluppo locale.

   git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
   

2. Tornare al progetto Visione personalizzata e selezionare Add images (Aggiungi immagini).

3. Individuare il repository Git clonato in locale e passare alla prima cartella di immagini, Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Selezionare tutte le 10 immagini contenute nella cartella e scegliere Open (Apri).

4. Aggiungere il tag hemlock a questo gruppo di immagini e premere INVIO per applicarlo.

5. Selezionare Upload 10 files (Carica 10 file).

   

6. Al termine del caricamento, selezionare Done (Fine).

7. Selezionare di nuovo Add images (Aggiungi immagini).

8. Passare alla seconda cartella di immagini, Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Selezionare tutte le 10 immagini contenute nella cartella e scegliere Open (Apri).

9. Aggiungere il tag japanese cherry a questo gruppo di immagini e premere INVIO per applicarlo.

10. Selezionare Upload 10 files (Carica 10 file). Al termine del caricamento, selezionare Done (Fine).

11. Dopo aver applicato il tag a entrambi i set di immagini e averli caricati, selezionare Train (Esegui il training) per eseguire il training del classificatore.

Esportare il classificatore

1. Completato il training del classificatore, selezionare Export (Esporta) nella pagina delle prestazioni del classificatore.

   

2. Selezionare DockerFile per la piattaforma.

3. Selezionare Linux per la versione.

4. Selezionare Esporta.

   

5. Al termine dell'esportazione, selezionare Download (Scarica) e salvare il pacchetto ZIP nel computer locale. Estrarre tutti i file dal pacchetto. Si usano questi file per creare un modulo IoT Edge contenente il server di classificazione delle immagini.

A questo punto la creazione e il training del progetto Visione personalizzata sono terminati. I file esportati verranno usati nella sezione successiva, ma non occorre più usare la pagina Web Visione personalizzata.

Creare una soluzione IoT Edge

I file per una versione contenitore del classificatore di immagini sono ora disponibili nel computer di sviluppo. In questa sezione il contenitore del classificatore di immagini verrà configurato in modo da essere eseguito come un modulo IoT Edge. Si crea anche un secondo modulo da distribuire insieme al classificatore di immagini. Il secondo modulo pubblica le richieste nel classificatore e invia i risultati come messaggi all'hub IoT.

Creare una nuova soluzione

Una soluzione è un modo logico per sviluppare e organizzare più moduli per una singola distribuzione IoT Edge. Una soluzione contiene il codice per uno o più moduli e il manifesto di distribuzione che dichiara come configurarli in un dispositivo IoT Edge.

1. In Visual Studio Code selezionare Visualizza>Riquadro comandi per aprire il riquadro comandi di Visual Studio Code.

2. Nel riquadro comandi immettere ed eseguire il comando Azure IoT Edge: New IoT Edge solution (Azure IoT Edge: Nuova soluzione IoT Edge). Nel riquadro comandi immettere le informazioni seguenti per creare la soluzione:

   Campo	valore
   Seleziona cartella	Nel computer di sviluppo scegliere la posizione in cui Visual Studio Code dovrà creare i file della soluzione.
   Provide a solution name (Specificare un nome per la soluzione)	Immettere un nome descrittivo per la soluzione, come CustomVisionSolution, oppure accettare l'impostazione predefinita.
   Select module template (Selezionare un modello di modulo)	Scegliere Modulo Python.
   Provide a module name (Specificare un nome per il modulo)	Assegnare al modulo il nome classifier. È importante che il nome del modulo sia in lettere minuscole. IoT Edge fa distinzione tra maiuscole e minuscole nei moduli e questa soluzione usa una libreria che formatta tutte le richieste in minuscolo.
   Provide Docker image repository for the module (Specificare il repository di immagini Docker per il modulo)	Un repository di immagini include il nome del registro contenitori e il nome dell'immagine del contenitore. L'immagine del contenitore è prepopolata dall'ultimo passaggio. Sostituire localhost:5000 con il valore di Server di accesso del registro contenitori di Azure. È possibile recuperare il server di accesso dalla pagina Panoramica del registro contenitori nel portale di Azure. La stringa finale è simile a <nome registro>.azurecr.io/classifier.

   

La finestra di Visual Studio Code carica l'area di lavoro della soluzione IoT Edge.

Aggiungere le credenziali del registro

Il file dell'ambiente archivia le credenziali per il registro contenitori e le condivide con il runtime IoT Edge. Queste credenziali sono necessarie al runtime per eseguire il pull delle immagini private nel dispositivo IoT Edge.

L'estensione IoT Edge cerca di eseguire il pull delle credenziali del Registro Container da Azure, per inserirle nel file di ambiente. Verificare se le credenziali sono già incluse. In caso contrario, aggiungerle:

1. Nello strumento di esplorazione di Visual Studio Code aprire il file con estensione env.
2. Aggiornare i campi con i valori di nome utente e password copiati dal Registro Azure Container.
3. Fare clic su Salva per salvare il file.

Selezionare l'architettura di destinazione

Attualmente, Visual Studio Code consente di sviluppare moduli per dispositivi Linux AMD64 e Linux ARM32v7. È necessario selezionare l'architettura di destinazione per ogni soluzione, perché il contenitore viene creato ed eseguito in modo diverso in base al tipo di architettura. Il valore predefinito è Linux AMD64, che viene usato per questa esercitazione.

1. Aprire il riquadro comandi e cercare Azure IoT Edge: Impostare la piattaforma di destinazione predefinita per la soluzione Edgeoppure selezionare l'icona di scelta rapida nella barra laterale nella parte inferiore della finestra.

2. Nel riquadro comandi selezionare l'architettura di destinazione nell'elenco di opzioni. Per questa esercitazione si usa una macchina virtuale Ubuntu come dispositivo IoT Edge, quindi si mantiene il valore predefinito amd64.

Aggiungere il classificatore di immagini

Il modello di modulo Python in Visual Studio Code contiene del codice di esempio che può essere eseguito per testare IoT Edge. Questo codice non verrà usato in questo scenario. Usare invece la procedura descritta in questa sezione per sostituire il codice di esempio con il contenitore del classificatore di immagini esportato in precedenza.

1. In Esplora file passare al pacchetto di Visione personalizzata precedentemente scaricato ed estratto. Copiare tutto il contenuto del pacchetto estratto. Dovrebbe essere costituito da due cartelle, app e azureml, e due file, Dockerfile e README.

2. In Esplora file passare alla directory in cui si è indicato a Visual Studio Code di creare la soluzione IoT Edge.

3. Aprire la cartella del modulo classifier. Se sono stati usati i nomi suggeriti nella sezione precedente, la struttura delle cartelle è simile a CustomVisionSolution/modules/classifier.

4. Incollare i file nella cartella classifier.

5. Tornare alla finestra di Visual Studio Code. Ora l'area di lavoro della soluzione dovrebbe mostrare i file del classificatore di immagini nella cartella dei moduli.

   

6. Aprire il file module.json nella cartella classifier.

7. Aggiornare il parametro platforms in modo che punti al nuovo Dockerfile aggiunto e rimuovere tutte le opzioni tranne AMD64, che è l'unica architettura usata per questa esercitazione.

   "platforms": {
       "amd64": "./Dockerfile"
   }
   

8. Salva le modifiche.

Creare un modulo di videocamera simulata

Una distribuzione reale di Visione personalizzata includerebbe una videocamera che fornisce immagini o flussi video dal vivo. Per questo scenario si simulerà la videocamera compilando un modulo che invia un'immagine di test al classificatore di immagini.

Aggiungere e configurare un nuovo modulo

In questa sezione si aggiungerà un nuovo modulo alla stessa CustomVisionSolution e si specificherà il codice per creare la videocamera simulata.

1. Nella stessa finestra di Visual Studio Code usare il riquadro comandi per eseguire Azure IoT Edge: Aggiungi modulo IoT Edge. Nel riquadro comandi immettere le informazioni seguenti per il nuovo modulo:

   Richiesta	Valore
   Select deployment template file (Selezionare il file del modello di distribuzione)	Selezionare il file deployment.template.json nella cartella CustomVisionSolution.
   Select module template (Selezionare un modello di modulo)	Selezionare Modulo Python
   Provide a module name (Specificare un nome per il modulo)	Assegnare al modulo il nome cameraCapture
   Provide Docker image repository for the module (Specificare il repository di immagini Docker per il modulo)	Sostituire localhost:5000 con il valore di Server di accesso del Registro Azure Container. La stringa finale è simile a <nome registro>.azurecr.io/cameracapture.

   La finestra di Visual Studio Code carica il nuovo modulo nell'area di lavoro della soluzione e aggiorna il file deployment.template.json. Ora si dovrebbero vedere due cartelle di moduli: classifier e cameraCapture.

2. Aprire il file main.py nella cartella modules / cameraCapture.

3. Sostituire l'intero file con il codice seguente. Questo codice di esempio invia richieste POST al servizio di elaborazione delle immagini in esecuzione nel modulo classifier. Questo contenitore di modulo viene fornito con un'immagine di esempio da usare nelle richieste. Il codice crea quindi un pacchetto della risposta come messaggio dell'hub IoT e lo invia a una coda di output.

   # Copyright (c) Microsoft. All rights reserved.
   # Licensed under the MIT license. See LICENSE file in the project root for
   # full license information.
   
   import time
   import sys
   import os
   import requests
   import json
   from azure.iot.device import IoTHubModuleClient, Message
   
   # global counters
   SENT_IMAGES = 0
   
   # global client
   CLIENT = None
   
   # Send a message to IoT Hub
   # Route output1 to $upstream in deployment.template.json
   def send_to_hub(strMessage):
       message = Message(bytearray(strMessage, 'utf8'))
       CLIENT.send_message_to_output(message, "output1")
       global SENT_IMAGES
       SENT_IMAGES += 1
       print( "Total images sent: {}".format(SENT_IMAGES) )
   
   # Send an image to the image classifying server
   # Return the JSON response from the server with the prediction result
   def sendFrameForProcessing(imagePath, imageProcessingEndpoint):
       headers = {'Content-Type': 'application/octet-stream'}
   
       with open(imagePath, mode="rb") as test_image:
           try:
               response = requests.post(imageProcessingEndpoint, headers = headers, data = test_image)
               print("Response from classification service: (" + str(response.status_code) + ") " + json.dumps(response.json()) + "\n")
           except Exception as e:
               print(e)
               print("No response from classification service")
               return None
   
       return json.dumps(response.json())
   
   def main(imagePath, imageProcessingEndpoint):
       try:
           print ( "Simulated camera module for Azure IoT Edge. Press Ctrl-C to exit." )
   
           try:
               global CLIENT
               CLIENT = IoTHubModuleClient.create_from_edge_environment()
           except Exception as iothub_error:
               print ( "Unexpected error {} from IoTHub".format(iothub_error) )
               return
   
           print ( "The sample is now sending images for processing and will indefinitely.")
   
           while True:
               classification = sendFrameForProcessing(imagePath, imageProcessingEndpoint)
               if classification:
                   send_to_hub(classification)
               time.sleep(10)
   
       except KeyboardInterrupt:
           print ( "IoT Edge module sample stopped" )
   
   if __name__ == '__main__':
       try:
           # Retrieve the image location and image classifying server endpoint from container environment
           IMAGE_PATH = os.getenv('IMAGE_PATH', "")
           IMAGE_PROCESSING_ENDPOINT = os.getenv('IMAGE_PROCESSING_ENDPOINT', "")
       except ValueError as error:
           print ( error )
           sys.exit(1)
   
       if ((IMAGE_PATH and IMAGE_PROCESSING_ENDPOINT) != ""):
           main(IMAGE_PATH, IMAGE_PROCESSING_ENDPOINT)
       else: 
           print ( "Error: Image path or image-processing endpoint missing" )
   

4. Salvare il file main.py.

5. Aprire il file requirements.txt.

6. Aggiungere una nuova riga per una libreria da includere nel contenitore.

   requests
   

7. Salvare il file requirements.txt .

Aggiungere un'immagine di test al contenitore

Invece di usare una videocamera reale per fornire un feed di immagini per questo scenario, si userà una singola immagine di test. Un'immagine di test è inclusa nel repository GitHub precedentemente scaricato per le immagini di training in questa esercitazione.

1. Passare all'immagine di test nel percorso Cognitive-CustomVision-Windows / Samples / Images / Test.

2. Copiare test_image.jpg

3. Passare alla directory della soluzione IoT Edge e incollare l'immagine di test nella cartella modules / cameraCapture. L'immagine dovrebbe essere nella stessa cartella del file main.py modificato nella sezione precedente.

4. In Visual Studio Code aprire il file Dockerfile.amd64 per il modulo cameraCapture.

5. Dopo la riga che stabilisce la directory di lavoro, WORKDIR /app, aggiungere la riga di codice seguente:

   ADD ./test_image.jpg .
   

6. Salvare il Dockerfile.

Preparare un manifesto di distribuzione

Fino a questo punto dell'esercitazione è stato eseguito il training di un modello di Visione personalizzata per classificare immagini di alberi ed è stato creato un pacchetto di tale modello come modulo IoT Edge. Si è poi creato un secondo modulo in grado di eseguire query sul server di classificazione delle immagini e riportarne i risultati all'hub IoT. A questo punto si è pronti per creare il manifesto di distribuzione che indicherà a un dispositivo IoT Edge come avviare ed eseguire questi due moduli insieme.

L'estensione IoT Edge per Visual Studio Code fornisce un modello in ogni soluzione IoT Edge che semplifica la creazione di un manifesto di distribuzione.

1. Aprire il file deployment.template.json nella cartella della soluzione.

2. Trovare la sezione modules, che dovrebbe contenere tre moduli: i due creati nell'esercitazione, classifier e cameraCapture, e un terzo incluso per impostazione predefinita, SimulatedTemperatureSensor.

3. Eliminare il modulo SimulatedTemperatureSensor con tutti i relativi parametri. Lo scopo di questo modulo è fornire dati di esempio per gli scenari di test, che in questa distribuzione non sono necessari.

4. Se al modulo di classificazione delle immagini è stato assegnato un nome diverso da classifier, verificare che contenga solo lettere minuscole. Il modulo cameraCapture chiama il modulo Classifier mediante una libreria di richieste che formatta tutte le richieste in minuscolo, e IoT Edge rileva la differenza tra maiuscole e minuscole.

5. Aggiornare il parametro createOptions per il modulo cameraCapture con il codice JSON seguente. Queste informazioni creano nel contenitore di moduli le variabili di ambiente recuperate nel processo main.py. Includendo queste informazioni nel manifesto di distribuzione, è possibile modificare l'immagine o l'endpoint senza dover ricompilare l'immagine del modulo.

   "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
   

   Se al modulo di Visione personalizzata è stato assegnato un nome diverso da classifier, aggiornare di conseguenza il valore dall'endpoint di elaborazione delle immagini.

6. In fondo al file, aggiornare il parametro routes per il modulo $edgeHub. In questo modo i risultati della stima verranno instradati da cameraCapture all'hub IoT.

       "routes": {
         "cameraCaptureToIoTHub": "FROM /messages/modules/cameraCapture/outputs/* INTO $upstream"
       },
   

   Se al secondo modulo è stato assegnato un nome diverso da cameraCapture, aggiornare di conseguenza il valore di routes.

7. Salvare il file deployment.template.json.

Eseguire la compilazione e il push della soluzione IoT Edge

Dopo aver creato i due moduli e aver configurato il modello di manifesto della distribuzione, si è pronti per compilare le immagini del contenitore ed eseguirne il push nel registro contenitori.

Una volta inserite le immagini nel registro, è possibile distribuire la soluzione in un dispositivo IoT Edge. È possibile impostare i moduli in un dispositivo tramite l'hub IoT, ma è anche possibile accedere all'hub IoT e ai dispositivi tramite Visual Studio Code. In questa sezione si configura l'accesso all'hub IoT e quindi si usa Visual Studio Code per distribuire la soluzione nel dispositivo IoT Edge.

Prima di tutto, compilare la soluzione ed eseguirne il push nel registro contenitori.

1. Aprire il terminale integrato di Visual Studio Code selezionando Visualizza>Terminale.

2. Accedere a Docker immettendo il comando seguente nel terminale. Accedere con il nome utente, la password e il server di accesso del Registro Azure Container. È possibile recuperare questi valori dalla sezione Chiavi di accesso del registro nel portale di Azure.

   docker login -u <ACR username> -p <ACR password> <ACR login server>
   

   Potrebbe venire visualizzato un avviso di sicurezza in cui si consiglia l'uso di --password-stdin. Sebbene si tratti di una procedura consigliata per gli scenari di produzione, esula dell'ambito di questa esercitazione. Per altri dettagli, vedere le informazioni di riferimento sull'accesso a Docker.

3. Nello strumento di esplorazione di Visual Studio Code fare clic con il pulsante destro del mouse sul file deployment.template.json e scegliere Build and Push IoT Edge Solution (Compila ed esegui il push della soluzione IoT Edge).

   Il comando di creazione e push avvia tre operazioni. Prima di tutto, crea una nuova cartella nella soluzione denominata config che contiene il manifesto completo della distribuzione, basato sulle informazioni del modello di distribuzione e di altri file della soluzione. In secondo luogo, esegue docker build per creare l'immagine del contenitore in base al documento dockerfile appropriato per l'architettura di destinazione. Infine, esegue docker push per eseguire il push del repository di immagini nel registro contenitori.

   Questo processo può richiedere alcuni minuti quando viene eseguito per la prima volta, ma alla successiva esecuzione dei comandi avviene più rapidamente.

Distribuire i moduli nel dispositivo

Usare Esplora risorse di Visual Studio Code e l'estensione Azure IoT Edge per distribuire il progetto di modulo nel dispositivo IoT Edge. Il manifesto della distribuzione, il file deployment.amd64.json, è già disponibile per questo scenario nella cartella config. Ora è sufficiente selezionare un dispositivo che riceverà la distribuzione.

Assicurarsi che il dispositivo IoT Edge sia in esecuzione.

1. Nello strumento di esplorazione di Visual Studio Code espandere Dispositivi nella sezione Azure IoT Hub (Hub IoT di Azure) per visualizzare l'elenco dei dispositivi IoT.

2. Fare clic con il pulsante destro del mouse sul nome del dispositivo IoT Edge, quindi selezionare Create Deployment for Single Device (Crea la distribuzione per un unico dispositivo).

3. Selezionare il file deployment.amd64.json nella cartella config e quindi fare clic su Select Edge Deployment Manifest (Seleziona il manifesto della distribuzione di Edge). Non usare il file deployment.template.json.

4. Nel dispositivo espandere Moduli per visualizzare un elenco dei moduli distribuiti e in esecuzione. Selezionare il pulsante Aggiorna. Verranno visualizzati i nuovi moduli classifier e cameraCapture in esecuzione insieme a $edgeAgent e $edgeHub.

È anche possibile verificare che tutti i moduli siano operativi nel dispositivo. Nel dispositivo IoT Edge eseguire questo comando per visualizzare lo stato dei moduli.

iotedge list

L'avvio dei moduli potrebbe richiedere alcuni minuti. Il runtime IoT Edge deve ricevere il nuovo manifesto della distribuzione, eseguire il pull delle immagini dei moduli dal runtime del contenitore e quindi avviare ogni nuovo modulo.

Visualizzare i risultati della classificazione

È possibile visualizzare i risultati dei moduli in due modi: nel dispositivo stesso quando i messaggi vengono generati e inviati oppure da Visual Studio Code man mano che i messaggi arrivano all'hub IoT.

Dal dispositivo, visualizzare i log del modulo cameraCapture per vedere i messaggi inviati e la conferma che siano stati ricevuti dall'hub IoT.

iotedge logs cameraCapture

Ad esempio, verrà visualizzato un output simile al seguente:

admin@vm:~$ iotedge logs cameraCapture
Simulated camera module for Azure IoT Edge. Press Ctrl-C to exit.
The sample is now sending images for processing and will indefinitely.
Response from classification service: (200) {"created": "2023-07-13T17:38:42.940878", "id": "", "iteration": "", "predictions": [{"boundingBox": null, "probability": 1.0, "tagId": "", "tagName": "hemlock"}], "project": ""}

Total images sent: 1
Response from classification service: (200) {"created": "2023-07-13T17:38:53.444884", "id": "", "iteration": "", "predictions": [{"boundingBox": null, "probability": 1.0, "tagId": "", "tagName": "hemlock"}], "project": ""}

È anche possibile visualizzare i messaggi da Visual Studio Code. Fare clic con il pulsante destro del mouse sul nome del dispositivo IoT Edge e scegliere Avvia monitoraggio endpoint eventi predefinito.

[IoTHubMonitor] [2:43:36 PM] Message received from [vision-device/cameraCapture]:
{
  "created": "2023-07-13T21:43:35.697782",
  "id": "",
  "iteration": "",
  "predictions": [
    {
      "boundingBox": null,
      "probability": 1,
      "tagId": "",
      "tagName": "hemlock"
    }
  ],
  "project": ""
}

I risultati del modulo di Visione personalizzata, inviati come messaggi dal modulo cameraCapture, includono la probabilità che l'immagine sia un abete canadese o un ciliegio. Poiché l'immagine corrisponde a un abete canadese, la probabilità dovrebbe essere indicata come 1.0.

Pulire le risorse

Se si intende continuare con il prossimo articolo consigliato, è possibile conservare le risorse e le configurazioni create e riutilizzarle. È anche possibile continuare a usare lo stesso dispositivo IoT Edge come dispositivo di test.

In caso contrario, è possibile eliminare le configurazioni locali e le risorse di Azure usate in questo articolo per evitare addebiti.

Eliminare le risorse di Azure

L'eliminazione delle risorse e dei gruppi di risorse di Azure è irreversibile. Assicurarsi di non eliminare accidentalmente il gruppo di risorse sbagliato o le risorse errate. Se l'hub IoT è stato creato all'interno di un gruppo di risorse esistente che contiene risorse che si vogliono conservare, eliminare solo la risorsa hub IoT stessa, invece dell'intero gruppo.

Per eliminare le risorse:

1. Accedere al portale di Azure e selezionare Gruppi di risorse.

2. Selezionare il nome del gruppo di risorse contenente le risorse di test di IoT Edge.

3. Esaminare l'elenco delle risorse contenute nel gruppo di risorse. Per eliminarle tutte, è possibile selezionare Elimina gruppo di risorse. Se se ne vogliono eliminare solo alcune, è possibile selezionare ogni risorsa per eliminarle singolarmente.

Passaggi successivi

In questa esercitazione è stato eseguito il training di un modello di Visione personalizzata, che è stato poi distribuito come modulo in un dispositivo IoT Edge. Si è poi compilato un modulo in grado di eseguire query sul server di classificazione delle immagini e riportarne i risultati all'hub IoT.

Continuare con le esercitazioni successive per ottenere informazioni sugli altri modi in cui Azure IoT Edge può contribuire alla trasformazione dei dati in informazioni dettagliate aziendali nei dispositivi perimetrali.