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

Artikel
04/11/2024

Van toepassing op: IoT Edge 1.5 IoT Edge 1.4

Belangrijk

IoT Edge 1.5 LTS en IoT Edge 1.4 LTS worden ondersteund releases. IoT Edge 1.4 LTS eindigt op 12 november 2024. Raadpleeg IoT Edge bijwerken als u een eerdere versie hebt.

Met Azure IoT Edge kunt uw IoT-oplossing efficiënter maken door werkbelastingen 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 samen kunt u inzichten vinden op basis van afbeeldingen of videostreams zonder dat u eerst alle gegevens van de site moet overbrengen. Custom Vision biedt een classificatie die een installatiekopie vergelijkt met een getraind model om inzichten te genereren.

Zo kunt u met Custom Vision op een IoT Edge-apparaat bepalen of er op een snelweg meer of minder verkeer is dan normaal, en of er in een parkeergarage nog vrije plaatsen zijn in een rij. Deze inzichten kunnen worden gedeeld met een andere service om actie te ondernemen.

In deze zelfstudie leert u het volgende:

Een afbeeldingsclassificatie bouwen met Custom Vision.
Een IoT Edge-module ontwikkelen die gegevens opvraagt van de Custom Vision-webserver op uw apparaat.
De resultaten van de afbeeldingsclassificatie verzenden naar IoT Hub.

Diagram - architectuur van zelfstudie, classificatie faseren en implementeren

Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

Vereisten

Tip

Deze zelfstudie is een vereenvoudigde versie van het voorbeeldproject Custom Vision en Azure IoT Edge op een Raspberry Pi 3. Deze zelfstudie is ontworpen om te worden uitgevoerd op een virtuele machine in de cloud en maakt gebruik van statische afbeeldingen om de functie voor afbeeldingsclassificatie te trainen en te testen, wat handig is voor iemand die net begint met het evalueren van Custom Vision in IoT Edge. Het voorbeeldproject maakt gebruik van fysieke hardware en stelt een live camerafeed in voor het trainen en testen van de functie voor afbeeldingsclassificatie, wat handig is voor iemand die een meer gedetailleerd praktijkscenario wil uitproberen.

Configureer uw omgeving voor het ontwikkelen van Linux-containers door zelfstudie: IoT Edge-modules ontwikkelen met behulp van Visual Studio Code. Nadat u de zelfstudie hebt voltooid, moet u beschikken over de volgende vereisten in uw ontwikkelomgeving:
- Een gratis of standaard IoT Hub-laag in Azure.
- Een apparaat met Azure IoT Edge met Linux-containers. U kunt de quickstarts gebruiken om een Linux-apparaat of Windows-apparaat in te stellen.
- Een containerregister, zoals Azure Container Registry.
- Visual Studio Code geconfigureerd met de Azure IoT Edge - en Azure IoT Hub-extensies . De Azure IoT Edge-hulpprogramma's voor de Visual Studio Code-extensie bevindt zich in de onderhoudsmodus.
- Download en installeer een docker-compatibel containerbeheersysteem op uw ontwikkelcomputer. Configureer deze om Linux-containers uit te voeren.
Om een IoT Edge-module te ontwikkelen met de Custom Vision-service, moeten de volgende aanvullende vereisten op uw ontwikkelcomputer zijn geïnstalleerd:

Een afbeeldingsclassificatie bouwen met Custom Vision

Voor het bouwen van een afbeeldingsclassificatie moet u een Custom Vision-project maken en trainingsafbeeldingen verstrekken. Zie Een classificatie bouwen met Custom Vision voor meer informatie over de stappen die u in deze sectie uitvoert.

Wanneer de afbeeldingsclassificatie is gemaakt en getraind, kunt u deze als een Docker-container exporteren en implementeren op een IoT Edge-apparaat.

Een nieuw project maken

Navigeer in uw webbrowser naar de Custom Vision-webpagina.
Selecteer Aanmelden en meld u aan met het account dat u gebruikt om toegang te krijgen tot Azure-resources.
Selecteer Nieuw project.

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, ...)

Selecteer Project maken.

Afbeeldingen uploaden en de classificatie trainen

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

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
```
Ga terug naar uw Custom Vision-project en selecteer Afbeeldingen toevoegen.
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 de afbeeldingen in de map en kies Openen.
Voeg het label hemlock toe aan deze groep afbeeldingen en druk op Enter om het label toe te passen.
Selecteer 10 bestanden uploaden.
Wanneer de afbeeldingen zijn geüpload, selecteert u Gereed.
Selecteer opnieuw Afbeeldingen toevoegen.
Blader naar de tweede afbeeldingenmap, Cognitive-CustomVision-Windows / Samples / afbeeldingen / Japanese Cherry. Selecteer alle 10 de afbeeldingen in de map en kies Openen.
Voeg het label japanese cherry toe aan deze groep afbeeldingen en druk op Enter om het label toe te passen.
Selecteer 10 bestanden uploaden. Wanneer de afbeeldingen zijn geüpload, selecteert u Gereed.
Wanneer beide sets met afbeeldingen zijn gelabeld en geüpload, selecteert u Trainen om de classificatie te trainen.

De classificatie exporteren

Nadat u de classificatie hebt getraind, selecteert u Exporteren op de pagina Prestaties van de classificatie.
Selecteer DockerFile als platform.
Selecteer Linux als de versie.
Selecteer Exporteren.
Wanneer de export is voltooid, selecteert u Downloaden en slaat u het ZIP-pakket lokaal op uw computer op. Pak alle bestanden uit het pakket uit. U gebruikt 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 de afbeeldingsclassificatie op uw ontwikkelcomputer. In deze sectie configureert u de container van de afbeeldingsclassificatie om te worden uitgevoerd als een IoT Edge-module. U maakt ook een tweede module die naast de afbeeldingsclassificatie wordt geïmplementeerd. De tweede module stuurt aanvragen naar de classificatie en verzendt de resultaten als berichten naar IoT Hub.

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.

Selecteer in Visual Studio Code het opdrachtpalet Weergeven>om het opdrachtenpalet van Visual Studio Code te openen.

Voer in het opdrachtpalet de opdracht Azure IoT Edge: New IoT Edge solution in en voer deze uit. Geef in het opdrachtpalet de volgende informatie op om de oplossing te maken:

Veld	Waarde
Map selecteren	Kies de locatie op uw ontwikkelcomputer voor Visual Studio Code om de oplossingsbestanden te maken.
Een naam opgeven voor de oplossing	Voer een beschrijvende naam voor uw oplossing in, bijvoorbeeld CustomVisionSolution, of accepteer de standaardinstelling.
Modulesjabloon selecteren	Kies Python-module.
Een modulenaam opgeven	Noem de module classificatie. Het is belangrijk dat deze modulenaam kleine letters bevat. IoT Edge is hoofdlettergevoelig wat de verwijzing naar modules betreft, en deze oplossing gebruikt een bibliotheek die alle aanvragen opmaakt in kleine letters.
Opslagplaats voor Docker-afbeeldingen voor de module opgeven	Een opslagplaats voor afbeeldingen bevat de naam van het containerregister en de naam van uw containerafbeelding. De containerafbeelding wordt vooraf gevuld vanuit de laatste stap. Vervang localhost:5000 door de waarde van de aanmeldingsserver uit uw Azure-containerregister. U vindt de aanmeldingsserver op de overzichtspagina van het containerregister in de Azure-portal. De uiteindelijke tekenreeks ziet eruit als registernaam.azurecr.io/classifier>.<

Opslagplaats voor Docker-installatiekopieën opgeven

De werkruimte van de IoT Edge-oplossing wordt geladen in het Visual Studio Code-venster.

Uw registerreferenties toevoegen

In het omgevingsbestand worden de referenties voor het containerregister opgeslagen. Deze referenties worden gedeeld met de IoT Edge-runtime. De runtime heeft deze referenties nodig om uw persoonlijke installatiekopieën naar het IoT Edge-apparaat te halen.

De IoT Edge-extensie probeert uw containerregisterreferenties op te halen uit Azure en vult deze in het omgevingsbestand. Controleer of uw referenties al zijn toegevoegd. Als dat niet het geval is, voegt u ze nu toe:

Open in Visual Studio Code Explorer het .env-bestand.
Werk de velden gebruikersnaam en wachtwoord bij met de waarden die u hebt gekopieerd uit het Azure-containerregister.
Sla dit bestand op.

Notitie

In deze zelfstudie worden aanmeldingsreferenties voor beheerders gebruikt voor Azure Container Registry, wat handig is voor ontwikkelings- en testscenario's. Wanneer u klaar bent voor productiescenario's, wordt u aangeraden een optie voor verificatie met minimale bevoegdheden, zoals service-principals. Zie Toegang tot uw containerregister beheren voor meer informatie.

Uw doelarchitectuur selecteren

Momenteel kunt u met Visual Studio Code modules ontwikkelen voor apparaten met Linux AMD64 en Linux ARM32v7. U moet voor elke oplossing selecteren op welke architectuur u zich richt, omdat de container voor elk type architectuur anders wordt opgebouwd en anders wordt uitgevoerd. De standaardwaarde is Linux AMD64, wat we voor deze zelfstudie gebruiken.

Open het opdrachtenpalet en zoek naar Azure IoT Edge: Stel standaarddoelplatform voor Edge-oplossing in of selecteer het snelkoppelingspictogram in de zijbalk onder aan het venster.
Selecteer in het opdrachtpalet de doelarchitectuur in de lijst met opties. Voor deze zelfstudie gebruiken we een virtuele Ubuntu-machine als het IoT Edge-apparaat, dus behoud de standaard amd64.

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.

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.
Blader in de Verkenner naar de map die u hebt opgegeven als de map waarin Visual Studio Code uw IoT Edge-oplossing moet maken.
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.
Plak de bestanden in de map classificatie.
Ga terug naar het Visual Studio Code-venster. De oplossingswerkruimte moet nu de afbeeldingsclassificatiebestanden weergeven in de modulemap.
Open het bestand module.json in de map classificatie.
Werk de parameter platforms bij zodat deze verwijst naar het nieuwe Dockerfile dat u hebt toegevoegd en verwijder alle opties behalve AMD64. Dit is de enige architectuur die we voor deze zelfstudie gebruiken.
```
"platforms": {
    "amd64": "./Dockerfile"
}
```
Sla uw wijzigingen op.

Een module voor een gesimuleerde camera maken

In een echte Custom Vision-implementatie zou u een camera hebben die live afbeeldingen of videostreams levert. Voor dit scenario kunt u de camera simuleren door een module te bouwen die een testafbeelding naar de afbeeldingsclassificatie verzendt.

Een nieuwe module toevoegen en configureren

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

In hetzelfde Visual Studio Code-venster gebruikt u het opdrachtenpalet om Azure IoT Edge: IoT Edge-module toevoegen uit te voeren. Geef in het opdrachtenpalet de volgende informatie op voor uw nieuwe module:

Prompt	Weergegeven als
Implementatiesjabloonbestand selecteren	Selecteer het bestand deployment.template.json in de map CustomVisionSolution.
Modulesjabloon selecteren	Selecteer Python-module
Een modulenaam opgeven	Noem de module cameraCapture
Opslagplaats voor Docker-afbeeldingen voor de module opgeven	Vervang localhost:5000 door de waarde van Aanmeldingsserver voor uw Azure-containerregister. De uiteindelijke tekenreeks ziet er als volgt uit: <registernaam>.azurecr.io/cameracapture.

Het Visual Studio Code-venster laadt uw nieuwe module in de werkruimte van de oplossing en werkt het deployment.template.json bestand bij. Nu moet u twee modulemappen zien: classificatie en cameraCapture.

Open het bestand main.py in de map / cameraCapture van de module.

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" )

Sla het bestand main.py op.
Open het bestand requirements.txt .
Voeg een nieuwe regel toe om een bibliotheek in de container op te nemen.
```
requests
```
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.

Navigeer naar de testafbeelding in Cognitive-CustomVision-Windows / Samples / Images / Test.
Kopieertest_image.jpg
Blader naar de map van uw 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.
Open in Visual Studio Code het bestand Dockerfile.amd64 voor de cameraCapture-module.
Voeg na de regel die de werkmap instelt, WORKDIR /app, de volgende regel code toe:
```
ADD ./test_image.jpg .
```
Sla de Dockerfile op.

Een implementatiemanifest voorbereiden

U hebt tot nu toe in deze zelfstudie een Custom Vision-model getraind om afbeeldingen van bomen te classificeren, en u hebt dit model verpakt als een IoT Edge-module. Daarna hebt u een tweede module gemaakt die query's kan uitvoeren naar de afbeeldingsclassificatieserver en de resultaten kan rapporteren aan IoT Hub. Nu kunt u het implementatiemanifest gaan maken dat aan een IoT Edge-apparaat doorgeeft hoe deze twee modules samen kunnen worden gestart en uitgevoerd.

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

Open het bestand deployment.template.json in de oplossingsmap.
Zoek de sectie modules, drie modules moet bevatten: de twee die u hebt gemaakt, classificatie en cameraCapture, en een derde, die standaard is opgenomen, SimulatedTemperatureSensor.
Verwijder de module SimulatedTemperatureSensor met alle bijbehorende parameters. Deze module is opgenomen om voorbeeldgegevens voor testscenario's te verstrekken, maar deze is niet nodig in deze implementatie.
Als u de afbeeldingsclassificatiemodule een andere naam hebt gegeven dan classificatie, gebruik die naam dan en controleer of deze alleen kleine letters bevat. De module cameraCapture roept de classificatiemodule aan met behulp van een bibliotheek met aanvragen die alle aanvragen omzet in kleine letters, en IoT Edge is hoofdlettergevoelig.
Werk de parameter createOptions voor de module cameraCapture bij met de volgende JSON. Met deze informatie worden omgevingsvariabelen in de modulecontainer gemaakt die zijn opgehaald in het main.py-proces. Door deze gegevens op te nemen in het implementatiemanifest, kunt u de afbeelding of het eindpunt wijzigen zonder de moduleafbeelding opnieuw te moeten 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.
Werk onderaan het bestand de parameter routes voor de module $edgeHub bij. U wilt de voorspellingsresultaten van cameraCapture omleiden naar IoT Hub.
```
    "routes": {
      "cameraCaptureToIoTHub": "FROM /messages/modules/cameraCapture/outputs/* INTO $upstream"
    },
```
Als u de tweede module een andere naam hebt gegeven dan cameraCapture, werk dan de routewaarde dienovereenkomstig bij.
Sla het bestand deployment.template.json op.

Uw IoT Edge-oplossing bouwen en pushen

Nu beide modules zijn gemaakt en de implementatiemanifestsjabloon is geconfigureerd, kunt u de containerafbeeldingen gaan bouwen en naar uw containerregister pushen.

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, maar u hebt ook toegang tot uw IoT Hub en apparaten via Visual Studio Code. In deze sectie stelt u de toegang tot uw IoT Hub in en gebruikt u Visual Studio Code om uw oplossing te implementeren op uw IoT Edge-apparaat.

Eerst gaat u de oplossing bouwen en naar het containerregister pushen.

Open de in Visual Studio Code geïntegreerde terminal door View>Terminal te selecteren.
Meld u aan bij Docker door de volgende opdracht in de terminal in te voeren. Meld u aan met 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 <ACR username> -p <ACR password> <ACR login server>
```
Mogelijk wordt een beveiligingswaarschuwing weergegeven waarin het gebruik van --password-stdin wordt aanbevolen. 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.
Klik in Visual Studio Code Explorer met de rechtermuisknop op het bestand deployment.template.json en selecteer De oplossing Build en Push IoT Edge.

Met de opdracht voor bouwen en pushen worden drie bewerkingen gestart. Eerst wordt er een nieuwe map met de naam config in de oplossing gemaakt die het volledige implementatiemanifest bevat, die is gebouwd op basis van de informatie in de implementatiesjabloon en andere oplossingsbestanden. Daarna wordt docker build uitgevoerd om de containerinstallatiekopie te bouwen op basis van de juiste dockerfile voor uw doelarchitectuur. Vervolgens wordt docker push uitgevoerd om de opslagplaats van de installatiekopie naar het containerregister te pushen.

Dit proces kan de eerste keer enkele minuten duren, maar de volgende keer dat u de opdrachten uitvoert, wordt het sneller uitgevoerd.

Modules op het apparaat implementeren

Gebruik Visual Studio Code Explorer en de Azure IoT Edge-extensie om het moduleproject te implementeren op uw IoT Edge-apparaat. U hebt al een implementatiemanifest voorbereid voor uw scenario, namelijk het bestand deployment.amd64.json in de map config. U hoeft nu alleen nog maar een apparaat te selecteren dat de implementatie moet ontvangen.

Zorg ervoor dat uw IoT Edge-apparaat actief is.

Vouw in de Visual Studio Code Explorer, onder de sectie Azure IoT Hub, de optie Apparaten uit om de lijst met IoT-apparaten weer te geven.
Klik met de rechtermuisknop op de naam van het IoT Edge-apparaat en selecteer Implementatie voor één apparaat maken.
Selecteer het bestand deployment.amd64.json in de configuratiemap en selecteer vervolgens edge-implementatiemanifest. Gebruik het bestand deployment.template.json niet.
Vouw onder uw apparaat Modules uit voor een lijst met de geïmplementeerde en actieve modules. Selecteer de knop Vernieuwen. U ziet nu de nieuwe modules classifier en cameraCapture, die worden uitgevoerd samen met de $edgeAgent en $edgeHub.

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

Er zijn twee manieren waarop u de resultaten van uw modules kunt bekijken: op het apparaat zelf, via de berichten die worden gegenereerd en verzonden, of vanuit Visual Studio Code via de berichten die binnenkomen bij IoT Hub.

Bekijk op uw apparaat de logboeken van de module cameraCapture om de berichten te zien die zijn verzonden en de bevestiging dat ze zijn ontvangen door de 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": ""}

U kunt ook berichten van Visual Studio Code bekijken. Klik met de rechtermuisknop op de naam van uw IoT Edge-apparaat en selecteer Bewaking van ingebouwd gebeurteniseindpunt starten.

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

Notitie

Mogelijk ziet u in eerste instantie verbindingsfouten in de uitvoer van de cameraCapture-module. Dit komt door de vertraging tussen het implementeren en starten van de modules.

De cameraCapture-module probeert de verbinding automatisch opnieuw tot stand te brengen totdat dit is gelukt. Nadat de verbinding is geslaagd, ziet u de verwachte berichten voor afbeeldingsclassificatie.

De resultaten van de Custom Vision-module die worden verzonden als berichten van de cameraCapture-module, bevatten de waarschijnlijkheid dat de afbeelding van een hemlock of kersenboom is. Omdat het een afbeelding van een Canadese den is, moet u de waarschijnlijkheid 1.0 zien.

Resources opschonen

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

Anders kunt u de lokale configuraties en Azure-resources die u in dit artikel hebt gemaakt, verwijderen 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 in een bestaande resourcegroep hebt gemaakt met de resources die u wilt behouden, moet u alleen de IoT-hub zelf verwijderen en niet de resourcegroep.

Om de resources te verwijderen:

Meld u aan bij Azure Portal en selecteer vervolgens Resourcegroepen.
Selecteer de naam van de resourcegroep die uw IoT Edge-testresources bevat.
Bekijk de lijst met resources die zich in de resourcegroep bevinden. Als u alle mappen wilt verwijderen, kunt u Resourcegroep verwijderen selecteren. Als u slechts een deel ervan wilt verwijderen, kunt u in elke resource afzonderlijk klikken om ze 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.

Gegevens opslaan met SQL Server-databases