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. Azure AI Custom Vision kunt u aangepaste afbeeldingsclassificaties bouwen en deze als containers implementeren op apparaten. 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 op 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, maakt u een free-account voordat u begint.

Vereisten

• Stel uw omgeving in voor de ontwikkeling van Linux-containers door Tutorial: Ontwikkel IoT Edge modules met behulp van Visual Studio Code te voltooien met de voorkeursontwikkeltool Azure IoT Edge Dev Tool commandoregel-tool (CLI). Nadat u de zelfstudie hebt voltooid, moet u ervoor zorgen dat de volgende vereisten beschikbaar zijn in uw ontwikkelomgeving:

  • Een gratis of standaardlaag 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 ingesteld met de extensie Azure IoT Hub.
  • 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 Aanmeldgegevens en meld u aan met hetzelfde account dat u gebruikt voor toegang tot Azure resources.

3. Selecteer Nieuw project.

4. Maak uw project met de volgende waarden:

   Veld	Waarde
   Naam	Geef een naam op voor uw project, bijvoorbeeld EdgeTreeClassifier.
   Beschrijving	Optionele projectbeschrijving.
   Bron	Selecteer een van uw Azure resourcegroepen met een Custom Vision Service-resource of maak nieuwe 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 Een project maken.

Afbeeldingen uploaden en je classifier trainen

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

1. Kloon of download voorbeeldafbeeldingen van de Cognitive-CustomVision-Windows opslagplaats op 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 map met installatiekopieën Cognitive-CustomVision-Windows/Samples/Images/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 afbeeldingsmap, Cognitive-CustomVision-Windows/Samples/Images/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 uw classifier hebt getraind, selecteert u Exporteren op de pagina Prestaties van de classifier.

   

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 de 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 worden verzonden als berichten naar IoT Hub.

Een nieuwe oplossing maken

Een oplossing is een logische manier om meerdere modules te ontwikkelen en te organiseren voor één IoT Edge implementatie. 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 ontwikkelhulpprogramma Azure IoT Edge Dev Tool opdrachtregel (CLI). De eenvoudigste manier om het hulpprogramma te gebruiken, is door Run the IoT Edge Dev Container with Docker.

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. Open uw Bestandsverkenner en navigeer naar de map waar u Visual Studio Code hebt geïnstrueerd om uw IoT Edge-oplossing te 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 venster Visual Studio Code. De oplossingswerkruimte moet nu de afbeeldingsclassificatorbestanden 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 verzonden naar een uitvoerwachtrij.

   # 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. Een testafbeelding is opgenomen in de GitHub opslagplaats die u eerder in deze zelfstudie hebt gedownload voor de trainingsafbeeldingen.

1. Navigeer naar de testafbeelding, bevindt zich op Cognitive-CustomVision-Windows / Samples / Images / Test.

2. Kopieertest_image.jpg

3. Blader naar de map van de IoT Edge oplossing en plak de testafbeelding in de map modules / cameracapture. 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 in deze zelfstudie hebt u 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 om u te helpen bij 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 Access-sleutels van uw Azure containerregister in de 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 classifier, controleer de naam dan en zorg ervoor dat 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.

Zodra de afbeeldingen zich in uw register bevinden, 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 toegang tot uw IoT Hub in en gebruikt u vervolgens Azure CLI om uw oplossing op uw IoT Edge-apparaat te implementeren.

Bouw en push eerst de oplossing naar het containerregister.

1. Open de geïntegreerde terminal van Visual Studio Code door Weergave>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 uit de sectie Access-sleutels van het register in de Azure-portal.

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

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

3. Gebruik het Dockerfile van de module om de Docker-image van de module te bouwen en te 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-afbeelding van Push-module

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 waarin het gebruik van --password-stdin wordt aanbevolen. 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 Install Azure CLI gebruiken om de opdracht az te gebruiken. Met deze opdracht wordt u gevraagd om uw gebruikersnaam en wachtwoord gevonden in uw containerregister onder Instellingen>Toegangssleutels.

   az acr login -n <AcrRegistryName>
   

   Aanbeveling

   Als u op enig moment tijdens deze handleiding wordt afgemeld, herhaalt u de aanmeldingsstappen voor Docker en Azure Container Registry om door te gaan.

3. Push de module-afbeelding naar de lokale registry 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": {
          "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 IoT Edge Azure CLI set-modules om de modules in de Azure IoT Hub te implementeren. Als u bijvoorbeeld de modules wilt implementeren die zijn gedefinieerd in het bestand deployment.template.json naar IoT Hub <IotHubName> voor het IoT Edge apparaat <DeviceName> gebruikt u de volgende opdracht. Vervang de waarden voor hub-name, device-id en login IoT Hub connection string door uw eigen waarden.

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 draait.

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 zien.

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

De uitvoer ziet er bijvoorbeeld als volgt uit:

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

U kunt het verwijderen van Azure resources en resourcegroepen niet ongedaan maken. Zorg ervoor dat u niet per ongeluk de verkeerde resourcegroep of bronnen 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 de Azure-portal en selecteer vervolgens Resource-groepen.
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, selecteert u elke resource om ze afzonderlijk te verwijderen.

Volgende stappen

In deze zelfstudie hebt u een Custom Vision-model getraind en geïmplementeerd als een module op een IoT Edge apparaat. Vervolgens hebt u een module gemaakt waarmee u een query kunt uitvoeren op de service voor afbeeldingsclassificatie en de resultaten kunt rapporteren aan IoT Hub.

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