Zelfstudie: Custom Vision Service gebruiken om afbeeldingsclassificatie uit te voeren aan de rand

Van toepassing op: IoT Edge 1.5

Azure IoT Edge maakt IoT-oplossingen efficiënter door workloads van de cloud naar de rand te verplaatsen. Deze mogelijkheid leent zich goed voor services die grote hoeveelheden gegevens verwerken, zoals computer vision-modellen. Met Azure AI Custom Vision kunt u aangepaste afbeeldingsclassificaties bouwen en implementeren op apparaten als containers. Met deze twee services kunnen gebruikers inzichten vinden uit afbeeldingen of videostreams zonder eerst alle gegevens buiten de site over te dragen. Custom Vision biedt een classificatie waarmee afbeeldingen worden vergeleken met een getraind model om inzichten te genereren.

Custom Vision op een IoT Edge-apparaat kan bijvoorbeeld bepalen of een snelweg een hoger of lager verkeer heeft dan normaal, of als een parkeergarage beschikbare parkeerplaatsen in een rij heeft. Deze inzichten kunnen worden gedeeld met een andere service om actie te ondernemen.

In deze zelfstudie leert u het volgende:

Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.

Vereisten

• Stel uw omgeving in voor het ontwikkelen van Linux-containers door de zelfstudie te voltooien: IoT Edge-modules ontwikkelen met behulp van Visual Studio Code met het favoriete azure IoT Edge Dev Tool-opdrachtregelprogramma (CLI). Nadat u de zelfstudie hebt voltooid, moet u ervoor zorgen dat de volgende vereisten beschikbaar zijn in uw ontwikkelomgeving:

  • Een gratis of standaardniveau IoT Hub in Azure
  • Een apparaat met Azure IoT Edge met Linux-containers. Gebruik de quickstarts om een Linux-apparaat of Windows-apparaat in te stellen.
  • Een containerregister, zoals Azure Container Registry.
  • Visual Studio Code is ingesteld met de Azure IoT Hub-extensie .
  • Download en installeer een docker-compatibel containerbeheersysteem op uw ontwikkelcomputer. Stel deze in om Linux-containers uit te voeren.

• Als u een IoT Edge-module wilt ontwikkelen met de Custom Vision-service, moet u ervoor zorgen dat de volgende aanvullende vereisten zijn geïnstalleerd op uw ontwikkelcomputer:

  • Python
  • Git
  • Python-extensie voor Visual Studio Code

Een afbeeldingsclassificatie bouwen met Custom Vision

Als u een afbeeldingsclassificatie wilt maken, maakt u een Custom Vision-project en geeft u trainingsafbeeldingen. Zie Een classificatie bouwen met Custom Vision voor meer informatie over de stappen die u in deze sectie uitvoert.

Nadat u uw afbeeldingsclassificatie hebt gebouwd en getraind, exporteert u deze als een Docker-container en implementeert u deze op een IoT Edge-apparaat.

Een nieuw project maken

1. Navigeer in uw webbrowser naar de Custom Vision-webpagina.

2. Selecteer Aanmelden en meld u aan met het account dat u gebruikt om toegang te krijgen tot Azure-resources.

3. Selecteer Nieuw project.

4. Maak uw project met de volgende waarden:

   Veld	Weergegeven als
   Naam	Geef een naam op voor uw project, bijvoorbeeld EdgeTreeClassifier.
   Beschrijving	Optionele projectbeschrijving.
   Bron	Selecteer een van uw Azure-resource groepen die een Custom Vision Service Resource bevat of maak nieuwe groepen als u er nog geen hebt toegevoegd.
   Projecttypen	Classificatie
   Classificatietypen	Multiclass (één label per afbeelding)
   Domeinen	Algemeen (compact)
   Exportmogelijkheden	Basisplatforms (TensorFlow, CoreML, ONNX, ...)

5. Selecteer Project maken.

Afbeeldingen uploaden en de classificatie trainen

Voor het maken van een afbeeldingsclassificatie is een set trainingsafbeeldingen en testafbeeldingen vereist.

1. U kunt voorbeeldafbeeldingen klonen of van de Cognitive-CustomVision-Windows- opslagplaats downloaden naar uw lokale ontwikkelcomputer.

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

2. Ga terug naar uw Custom Vision-project en selecteer Afbeeldingen toevoegen.

3. Blader naar de git-opslagplaats die u lokaal hebt gekloond en navigeer naar de eerste afbeeldingenmap, Cognitive-CustomVision-Windows / Samples / afbeeldingen / Hemlock. Selecteer alle 10 afbeeldingen in de map en selecteer vervolgens Openen.

4. Voeg de tag hemlock toe aan deze groep afbeeldingen en druk op Enter om de tag toe te passen.

5. Selecteer 10 bestanden uploaden.

   

6. Wanneer de afbeeldingen zijn geüpload, selecteert u Gereed.

7. Selecteer opnieuw Afbeeldingen toevoegen.

8. Blader naar de tweede afbeeldingenmap, Cognitive-CustomVision-Windows / Samples / afbeeldingen / Japanese Cherry. Selecteer alle 10 de afbeeldingen in de map en kies Openen.

9. Voeg het label japanese cherry toe aan deze groep afbeeldingen en druk op Enter om het label toe te passen.

10. Selecteer 10 bestanden uploaden. Wanneer de afbeeldingen zijn geüpload, selecteert u Gereed.

11. Nadat u beide sets afbeeldingen hebt getagd en geüpload, selecteert u Trainen om de classificatie te trainen.

De classificatie exporteren

1. Nadat u de classificatie hebt getraind, selecteert u Exporteren op de pagina Prestaties van de classificatie.

   

2. Selecteer DockerFile als platform.

3. Selecteer Linux als de versie.

4. Selecteer Exporteren.

5. Nadat het exporteren is voltooid, selecteert u Downloaden en slaat u het .zip-pakket lokaal op uw computer op. Pak alle bestanden uit het pakket uit. Gebruik deze bestanden om een IoT Edge-module te maken die de afbeeldingsclassificatieserver bevat.

Op dit punt aangekomen, bent u klaar met het maken en trainen van uw Custom Vision-project. U gebruikt de geëxporteerde bestanden in de volgende sectie, maar u bent klaar met de Custom Vision-webpagina.

Een IoT Edge-oplossing maken

U hebt nu de bestanden voor een containerversie van uw afbeeldingsclassificatie op uw ontwikkelcomputer. In deze sectie stelt u de container voor afbeeldingsclassificatie in om te worden uitgevoerd als een IoT Edge-module. U maakt ook een tweede module waarmee aanvragen naar de classificatie worden geplaatst en de resultaten als berichten naar IoT Hub worden verzonden.

Een nieuwe oplossing maken

Een oplossing is een logische manier om meerdere modules voor één IoT Edge-implementatie te ontwikkelen en te organiseren. Een oplossing bevat code voor een of meer modules en het implementatiemanifest waarmee wordt aangegeven hoe u deze configureert op een IoT Edge-apparaat. Maak de oplossing met behulp van het azure IoT Edge Dev Tool-opdrachtregelprogramma (CLI). De eenvoudigste manier om het hulpprogramma te gebruiken, is door de IoT Edge Dev-container met Docker uit te voeren.

1. Maak een map met de naam classificatie en ga naar de map.

   mkdir CustomVisionSolution
   cd CustomVisionSolution
   

2. Voer de init-opdracht iotedgedev uit om een nieuwe IoT Edge-oplossing te maken. Voer in de IoT Edge Dev Docker-container de volgende opdracht in:

   iotedgedev solution init --template python --module classifier
   

   In het init-script van de iotedgedev-oplossing wordt u gevraagd om verschillende stappen uit te voeren, waaronder:

   • Verifiëren bij Azure
   • Een Azure-abonnement kiezen
   • Een resourcegroep kiezen of maken
   • Een Azure IoT Hub kiezen of maken
   • Een Azure IoT Edge-apparaat kiezen of maken

   Met de opdracht maakt u een nieuwe IoT Edge-oplossing met een module met de naam Classificatie in de huidige werkmap.

3. Open de oplossing in Visual Studio Code.

Een afbeeldingsclassificatie toevoegen

De Python-modulesjabloon in Visual Studio Code bevat enkele voorbeeldcode die u kunt uitvoeren om IoT Edge te testen. U gaat deze code niet gebruiken in dit scenario. Gebruik in plaats daarvan de stappen in deze sectie om de voorbeeldcode te vervangen door de container van de afbeeldingsclassificatie die u eerder hebt geëxporteerd.

1. Blader in de Verkenner naar het Custom Vision-pakket dat u hebt gedownload en uitgepakt. Kopieer de volledige inhoud van het uitgepakte pakket. Deze bestaat uit de mappen app en azureml, en de bestanden Dockerfile en README.

2. Blader in de Verkenner naar de map die u hebt opgegeven als de map waarin Visual Studio Code uw IoT Edge-oplossing moet maken.

3. Open de map met de classificatiemodule. Als u de voorgestelde namen in de vorige sectie hebt gebruikt, ziet de mapstructuur er ongeveer zo uit: CustomVisionSolution / modules / classificatie.

4. Plak de bestanden in de map classificatie.

5. Ga terug naar het Visual Studio Code-venster. De oplossingswerkruimte moet nu de afbeeldingsclassificatiebestanden weergeven in de modulemap.

6. Vervang het oorspronkelijke Dockerfile.amd64-bestand door het Dockerfile uit het custom vision-pakket door het oorspronkelijke Dockerfile.amd64 te verwijderen en de naam van Dockerfile te wijzigen in Dockerfile.amd64.

7. Sla uw wijzigingen op.

Een module voor een gesimuleerde camera maken

In een echte custom vision-implementatie biedt een camera livebeelden of videostreams. Voor dit scenario kunt u de camera simuleren door een module te bouwen die een testafbeelding naar de afbeeldingsclassificatie verzendt.

In deze sectie voegt u een nieuwe module aan dezelfde CustomVisionSolution toe en geeft u code op om de gesimuleerde camera te maken.

1. Gebruik het iotedgedev-hulpprogramma om een nieuwe module aan de oplossing toe te voegen. Met de opdracht maakt u een nieuwe map met de naam cameracapture in de map modules van uw oplossing.

   iotedgedev solution add --template python cameracapture
   

2. Open het bestand main.pyin de map / van modules.

3. Vervang het hele bestand door de volgende code. Deze voorbeeldcode verzendt POST-aanvragen naar de beeldverwerkingsservice die wordt uitgevoerd in de classificatiemodule. We geven deze modulecontainer met een voorbeeldafbeelding die u in de aanvragen kunt gebruiken. Vervolgens wordt het antwoord verpakt als een IoT Hub-bericht en naar een uitvoerwachtrij verzonden.

   # 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. Sla het bestand main.py op.

5. Open het bestand requirements.txt .

6. Voeg een nieuwe regel toe om een bibliotheek in de container op te nemen.

   requests
   

7. Sla het bestand requirements.txt op.

Een testafbeelding toevoegen aan de container

In plaats van een echte camera te gebruiken om dit scenario een afbeeldingsfeed te bieden, gebruiken we één testafbeelding. U vindt een testafbeelding in de GitHub-opslagplaats die u eerder in deze zelfstudie hebt gedownload voor de trainingsafbeeldingen.

1. Navigeer naar de testafbeelding in Cognitive-CustomVision-Windows / Samples / Images / Test.

2. Kopieertest_image.jpg

3. Blader naar de map van uw IoT Edge-oplossing en plak de testafbeelding in de mapcameracapture / . De afbeelding moet zich in dezelfde map bevinden als het bestand main.py dat u in de vorige sectie hebt bewerkt.

4. Open in Visual Studio Code het bestand Dockerfile.amd64 voor de cameracapture-module.

5. Voeg na de regel die de werkmap instelt, WORKDIR /app, de volgende regel code toe:

   ADD ./test_image.jpg .
   

6. Sla de Dockerfile op.

Een implementatiemanifest voorbereiden

Tot nu toe hebt u in deze zelfstudie een Custom Vision-model getraind om afbeeldingen van bomen te classificeren en dat model te verpakken als een IoT Edge-module. Vervolgens hebt u een tweede module gemaakt waarmee een query wordt uitgevoerd op de afbeeldingsclassificatieserver en de resultaten worden gerapporteerd aan IoT Hub. U bent nu klaar om het implementatiemanifest te maken dat aan een IoT Edge-apparaat vertelt hoe u deze twee modules samen kunt starten en uitvoeren.

De IoT Edge-extensie voor Visual Studio Code bevat een sjabloon in elke IoT Edge-oplossing voor het maken van een implementatiemanifest.

1. Open het bestand deployment.template.json in de oplossingsmap.

2. Stel de registerreferenties in voor de modules in het implementatiemanifest.

   "registryCredentials": {
       "<registryName>": {
           "username": "<AcrUsername>",
           "password": "<AcrPassword>",
           "address": "<registryName>.azurecr.io"
       }
   }
   

   Vervang <registryName> door de naam van uw Azure-containerregister en vervang <AcrUsername> en <AcrPassword> door de gebruikersnaam en het wachtwoord voor uw register. U vindt deze waarden in de sectie Toegangssleutels van uw Azure-containerregister in Azure Portal.

3. Zoek de modulesectie, die drie modules bevat: de twee die u hebt gemaakt, classificatie en cameracapture, en een derde die standaard tempSensor bevat.

4. Verwijder de tempSensor-module met alle parameters. Deze module bevat voorbeeldgegevens voor testscenario's, maar deze is niet nodig in deze implementatie.

5. Als u de afbeeldingsclassificatiemodule een andere naam hebt gegeven dan classificatie, gebruik die naam dan en controleer of deze alleen kleine letters bevat. De cameracapture-module roept de classificatiemodule aan met behulp van een aanvraagbibliotheek waarmee alle aanvragen in kleine letters worden opgemaakt en IoT Edge hoofdlettergevoelig is.

6. Wijzig voor elke systeemmodule edgeAgent en edgeHub de createOptions-waarde in een tekenreeksversie. Voorbeeld:

   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
   

7. Wijzig voor elke systeemmodule edgeAgent en edgeHub de afbeeldingversie naar de nieuwste versie 1.5. Voorbeeld:

   "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
   "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
   

8. Werk de parameter createOptions voor de classificatiemodule bij naar een tekenreeksversie. Voorbeeld:

   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
   

9. Werk de parameter createOptions voor de cameracapture-module bij met de volgende JSON. Met deze informatie worden omgevingsvariabelen in de modulecontainer gemaakt die zijn opgehaald in het main.py-proces. Als u deze informatie opneemt in het implementatiemanifest, kunt u de afbeelding of het eindpunt wijzigen zonder de module-afbeelding opnieuw op te bouwen.

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

   Als u de Custom Vision-module een andere naam hebt gegeven dan classificatie, werk dan de waarde van het afbeeldingsverwerkingseindpunt dienovereenkomstig bij.

   De configuratie van de classificatie en cameracapture moet bijvoorbeeld vergelijkbaar zijn met:

   "modules": {
       "classifier": {
           "version": "1.0",
           "type": "docker",
           "status": "running",
           "restartPolicy": "always",
           "settings": {
               "image": "${MODULES.classifier}",
               "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
           }
       },
       "cameracapture": {
           "version": "1.0",
           "type": "docker",
           "status": "running",
           "restartPolicy": "always",
           "settings": {
               "image": "${MODULES.cameracapture}",
               "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
           }
       }
   }
   

10. Sla het bestand deployment.template.json op.

Uw IoT Edge-oplossing bouwen en pushen

Nadat u beide modules hebt gemaakt en de sjabloon voor het distributiemanifest hebt geconfigureerd, bouwt u de containerinstallatiekopieën en pusht u deze naar uw containerregister.

Wanneer de afbeeldingen in het register staan, kunt u de oplossing implementeren op een IoT Edge-apparaat. U kunt modules op een apparaat instellen via de IoT Hub. In deze sectie stelt u de toegang tot uw IoT Hub in en gebruikt u vervolgens Azure CLI om uw oplossing te implementeren op uw IoT Edge-apparaat.

Bouw en push eerst de oplossing naar het containerregister.

1. Open de in Visual Studio Code geïntegreerde terminal door View>Terminal te selecteren.

2. Meld u aan bij Docker door de volgende opdracht in de terminal in te voeren met behulp van de gebruikersnaam, het wachtwoord en de aanmeldingsserver uit het Azure-containerregister. U kunt deze waarden ophalen in de sectie Toegangssleutels van het register in Azure Portal.

   docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
   

   Mogelijk ontvangt u een beveiligingswaarschuwing die het gebruik van --password-stdin. Hoewel dit wordt aanbevolen voor productiescenario's, valt het buiten het bereik van deze zelfstudie. Zie de documentatie voor aanmelding bij Docker voor meer informatie.

3. Gebruik het Dockerfile van de module om de Docker-installatiekopieën van de module te bouwen en taggen.

   docker build --rm -f "<DockerFilePath>" -t <ImageNameAndTag> "<ContextPath>" 
   

   Als u bijvoorbeeld de installatiekopieën voor het lokale register of een Azure-containerregister wilt maken, gebruikt u de volgende opdrachten:

   
   # Build and tag the image for an Azure Container Registry. Replace <AcrRegistryName> with your own registry name.
   
   docker build --rm -f "./modules/classifier/Dockerfile.amd64" -t <AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64 "./modules/classifier"
   docker build --rm -f "./modules/cameracapture/Dockerfile.amd64" -t <AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64 "./modules/cameracapture"
   

Docker-installatiekopieën van pushmodule

Geef uw containerregisterreferenties op voor Docker, zodat deze uw containerinstallatiekopieën naar de opslag in het register kan pushen.

1. Meld u aan bij Docker met de ACR-referenties (Azure Container Registry).

   docker login -u <AcrUsername> -p <AcrPassword> <AcrLoginServer>
   

   Mogelijk ontvangt u een beveiligingswaarschuwing die het gebruik van --password-stdin. Hoewel dit een aanbevolen best practice is voor productiescenario's, valt dit buiten het bereik van deze zelfstudie. Zie de documentatie voor aanmelding bij Docker voor meer informatie.

2. Meld u aan bij de Azure Container Registry. U moet Azure CLI installeren om de az opdracht te kunnen gebruiken. Met deze opdracht wordt u gevraagd om uw gebruikersnaam en wachtwoord in het containerregister in Toegangssleutels

   az acr login -n <AcrRegistryName>
   

   Aanbeveling

   Als u op enig moment in deze zelfstudie wordt afgemeld, herhaalt u de aanmeldingsstappen van Docker en Azure Container Registry om door te gaan.

3. Push de module-installatiekopieën naar het lokale register of een containerregister.

   docker push <ImageName>
   

   Voorbeeld:

   # Push the Docker image to an Azure Container Registry. Replace <AcrRegistryName> with your Azure Container Registry name.
   
   az acr login --name <AcrRegistryName>
   docker push <AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64
   docker push <AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64
   

De implementatiesjabloon bijwerken

Werk het deployment.template.json-bestand bij met de locatie van de containerregisterimage. Wijzig de image waarde naar de image die u naar het register hebt gepusht. Vervang <bijvoorbeeld AcrRegistryName> door uw registernaam in de afbeeldingswaarden voor de classificatie- en cameracapturemodules:

"classifier": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    },
    "cameracapture": {
        "version": "1.0",
        "type": "docker",
        "status": "running",
        "restartPolicy": "always",
        "settings": {
            "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
            "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
        }
    }
}

Het uiteindelijke implementatiemanifest ziet er ongeveer als volgt uit:

{
  "$schema-template": "4.0.0",
  "modulesContent": {
    "$edgeAgent": {
      "properties.desired": {
        "schemaVersion": "1.1",
        "runtime": {
          "type": "docker",
          "settings": {
            "minDockerVersion": "v1.25",
            "loggingOptions": "",
            "registryCredentials": {
              "<AcrRegistryName>": {
                "username": "<AcrUserName>",
                "password": "<AcrPassword>",
                "address": "<AcrRegistryName>.azurecr.io"
              }
            }
          }
        },
        "systemModules": {
          "edgeAgent": {
            "type": "docker",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-agent:1.5",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          },
          "edgeHub": {
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          }
        },
        "modules": {
          "classifier": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "<AcrRegistryName>.azurecr.io/classifier:0.0.1-amd64",
              "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
            }
          },
          "cameracapture": {
            "version": "1.0",
            "type": "docker",
            "status": "running",
            "restartPolicy": "always",
            "settings": {
              "image": "<AcrRegistryName>.azurecr.io/cameracapture:0.0.1-amd64",
              "createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
            }
          }
        }
      }
    },
    "$edgeHub": {
      "properties.desired": {
        "schemaVersion": "1.2",
        "routes": {
          "sensorToclassifier": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/classifier/inputs/input1\")",
          "classifierToIoTHub": "FROM /messages/modules/classifier/outputs/* INTO $upstream",
          "cameracaptureToIoTHub": "FROM /messages/modules/cameracapture/outputs/* INTO $upstream"
        },
        "storeAndForwardConfiguration": {
          "timeToLiveSecs": 7200
        }
      }
    }
  }
}

Modules op het apparaat implementeren

Controleer of gemaakte containerafbeeldingen zijn opgeslagen in uw containerregistry. Implementeer ze vervolgens op een apparaat met behulp van het implementatiemanifest deployment.template.json voorbereid voor uw scenario.

Gebruik de opdracht Azure CLI-setmodules voor IoT Edge om de modules te implementeren in de Azure IoT Hub. Als u bijvoorbeeld de modules wilt implementeren die zijn gedefinieerd in het deployment.template.json-bestand naar IoT Hub <IotHubName voor het IoT Edge-apparaat >DeviceName<>, gebruikt u de volgende opdracht. Vervang de waarden voor hubnaam, apparaat-id en meld u aan bij IoT Hub verbindingsreeks door uw eigen.

az iot edge set-modules --hub-name <IotHubName> --device-id <DeviceName> --content ./deployment.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

Zorg ervoor dat uw IoT Edge-apparaat actief is.

Vouw onder uw apparaat Modules uit voor een lijst met de geïmplementeerde en actieve modules. Selecteer de knop Vernieuwen. U ziet de nieuwe classificatie- en cameracapture-modules die samen met $edgeAgent en $edgeHub worden uitgevoerd.

U kunt ook controleren of alle modules op uw eigen apparaat actief zijn. Voer op uw IoT Edge-apparaat de volgende opdracht uit om de status van de modules te bekijken.

iotedge list

Het kan enkele minuten duren voordat de modules zijn gestart. De IoT Edge-runtime moet het nieuwe implementatiemanifest ontvangen, de module-installatiekopieën uit de containerruntime ophalen en vervolgens elke nieuwe module starten.

Classificatieresultaten weergeven

Bekijk op uw apparaat de logboeken van de cameracapture-module om de verzonden berichten te bekijken en te bevestigen dat ze worden ontvangen door IoT Hub.

iotedge logs cameracapture

U ziet bijvoorbeeld uitvoer als het volgende:

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": ""}

De resultaten van de Custom Vision-module, verzonden als berichten van de cameracapture-module, bevatten de waarschijnlijkheid dat de afbeelding een hemlock of kersenboom is. Omdat de afbeelding hemlock toont, ziet u dat de kans 1,0 is.

Resources opschonen

Als u van plan bent door te gaan naar het volgende aanbevolen artikel, bewaart u de resources en configuraties die u hebt gemaakt en gebruikt u deze opnieuw. U kunt ook hetzelfde IoT Edge-apparaat blijven gebruiken als een testapparaat.

Verwijder anders de lokale configuraties en de Azure-resources die u in dit artikel hebt gebruikt om kosten te voorkomen.

Azure-resources verwijderen

Het verwijderen van de Azure-resources en resourcegroepen kan niet ongedaan worden gemaakt. Zorg ervoor dat u niet per ongeluk de verkeerde resourcegroep of resources verwijdert. Als u de IoT Hub hebt gemaakt in een bestaande resourcegroep met resources die u wilt behouden, verwijdert u alleen de IoT Hub-resource zelf, niet de resourcegroep.

Om de resources te verwijderen:

1. Meld u aan bij Azure Portal en selecteer vervolgens Resourcegroepen.

2. Selecteer de naam van de resourcegroep die uw IoT Edge-testresources bevat.

3. Bekijk de lijst met resources die uw resourcegroep bevat. Als u alle mappen wilt verwijderen, kunt u Resourcegroep verwijderen selecteren. Als u slechts enkele resources wilt verwijderen, kunt u elke resource selecteren om ze afzonderlijk te verwijderen.

Volgende stappen

In deze zelfstudie hebt u een Custom Vision-model getraind en het als een module op een IoT Edge-apparaat geïmplementeerd. Daarna hebt u een module gemaakt die query's kan uitvoeren naar de afbeeldingsclassificatieservice en de resultaten kan rapporteren aan IoT Hub.

Ga verder met de volgende zelfstudies voor meer informatie over andere manieren waarop Azure IoT Edge u kan helpen bij het omzetten van gegevens in zakelijke inzichten aan de rand.