Självstudie: Utföra bildklassificering på gränsen med Custom Vision Service

Artikel
04/11/2024

Gäller för: IoT Edge 1.5 IoT Edge 1.4

Viktigt!

IoT Edge 1.5 LTS och IoT Edge 1.4 LTS stöds. IoT Edge 1.4 LTS upphör den 12 november 2024. Om du har en tidigare version läser du Uppdatera IoT Edge.

Azure IoT Edge kan göra din IoT-lösning effektivare genom att flytta arbetsbelastningar från molnet till gränsen. Den här funktionen lämpar sig väl för tjänster som bearbetar stora mängder data, till exempel modeller för visuellt innehåll. Med Azure AI Custom Vision kan du skapa anpassade bildklassificerare och distribuera dem till enheter som containrar. Tillsammans gör de här två tjänsterna att du kan få insikter från bilder eller videoströmmar utan att först behöva överföra alla data till annan plats. Custom Vision tillhandahåller en klassificerare som jämför en bild mot en tränad modell att generera insikter.

Till exempel kan Custom Vision på en IoT Edge-enhet avgöra om det förekommer mer eller mindre trafik än normalt på en motorväg eller huruvida det finns lediga platser på en viss sträcka i ett parkeringshus. Dessa insikter kan delas med en annan tjänst i åtgärdssyfte.

I den här självstudien lär du dig att:

Skapa en bildklassificerare med Custom Vision.
Utveckla en IoT Edge-modul som kör frågor mot Custom Vision-webbservern på din enhet.
Skicka resultaten från bildklassificeraren till IoT Hub.

Diagram – Självstudiearkitektur, steg- och distributionsklassificerare

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Förutsättningar

Dricks

Den här självstudien är en förenklad version av Custom Vision och Azure IoT Edge i ett Raspberry Pi 3-exempelprojekt . Den här självstudien har utformats för att köras på en virtuell molndator och använder statiska avbildningar för att träna och testa bildklassificeraren, vilket är användbart för någon som precis har börjat utvärdera Custom Vision på IoT Edge. Exempelprojektet använder fysisk maskinvara och konfigurerar en livekamerafeed för att träna och testa bildklassificeraren, vilket är användbart för någon som vill prova ett mer detaljerat scenario i verkligheten.

Konfigurera din miljö för utveckling av Linux-containrar genom att slutföra Självstudie: Utveckla IoT Edge-moduler med hjälp av Visual Studio Code. När du har slutfört självstudien bör du ha följande förutsättningar tillgängliga i utvecklingsmiljön:
- En IoT Hub på kostnadsfri nivå eller standardnivå i Azure.
- En enhet som kör Azure IoT Edge med Linux-containrar. Du kan använda snabbstarterna för att konfigurera en Linux-enhet eller Windows-enhet.
- Ett containerregister, till exempel Azure Container Registry.
- Visual Studio Code har konfigurerats med Azure IoT Edge - och Azure IoT Hub-tilläggen . Azure IoT Edge-verktygen för Visual Studio Code-tillägget är i underhållsläge.
- Ladda ned och installera ett Docker-kompatibelt containerhanteringssystem på utvecklingsdatorn. Konfigurera den för att köra Linux-containrar.
Om du vill utveckla en IoT Edge-modul med Custom Vision-tjänsten installerar du följande ytterligare krav på utvecklingsdatorn:
- Python
- Git
- Python-tillägg för Visual Studio Code

Skapa en bildklassificerare med Custom Vision

För att skapa en bildklassificerare måste du skapa ett Custom Vision-projekt och förse träningsbilder. Mer information om de steg som du vidtar i det här avsnittet finns på sidan om hur du skapar en klassificerare med Custom Vision.

När din bildklassificerare har skapats och tränats kan du exportera den som en Docker-container och distribuera den till en IoT Edge-enhet.

Skapa ett nytt projekt

I din webbläsare navigerar du till Custom Vision-webbplatsen.
Välj Logga in och logga in med samma konto som du använder för att få åtkomst till Azure-resurser.
Välj Nytt projekt.

Skapa ditt projekt med följande värden:

Fält	Värde
Name	Ange ett namn för projektet, till exempel EdgeTreeClassifier.
beskrivning	Valfri projektbeskrivning.
Resurs	Välj en av dina Azure-resursgrupper som innehåller en Custom Vision Service-resurs eller skapa en ny om du inte har lagt till en ännu.
Projekttyper	Omdöme
Klassificeringstyper	Multiklass (enskild tagg per bild)
Domäner	Allmän (kompakt)
Exportera funktioner	Grundläggande plattformar (Tensorflow, CoreML, ONNX, ...)

Välj Skapa projekt.

Ladda upp bilder och träna klassificeraren

För att skapa en bildklassificerare krävs en uppsättning träningsbilder och testbilder.

Klona eller ladda ned exempelbilder från lagringsplatsen Cognitive-CustomVision-Windows till din lokala utvecklingsdator.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Återgå till Custom Vision-projektet och välj Lägg till bilder.
Bläddra till den git-lagringsplats som du klonade lokalt och navigera till den första bildmappen, Cognitive-CustomVision-Windows/Samples/Images/Hemlock. Välj alla 10 bilder i mappen och sedan Öppna.
Lägg till taggen hemlock (hemlockgran) till den här gruppen med bilder och tryck på Retur för att tillämpa taggen.
Välj Ladda upp 10 filer.
När bilderna har laddats upp väljer du Klar.
Välj Lägg till bilder igen.
Bläddra till den andra bildmappen, Cognitive-CustomVision-Windows/Samples/Images/Japanese Cherry. Välj alla 10 bilder i mappen och sedan Öppna.
Lägg till taggen japanese cherry (japanskt körsbärsträd) till den här gruppen med bilder och tryck på Retur för att tillämpa taggen.
Välj Ladda upp 10 filer. När bilderna har laddats upp väljer du Klar.
När båda uppsättningarna med bilder har taggats och laddats upp väljer du Träna för att träna klassificeraren.

Exportera klassificeraren

När du har tränat klassificeraren väljer du Exportera på sidan Prestanda för klassificeraren.
Välj DockerFile som plattform.
Välj Linux som version.
Välj Exportera.
När exporten är klar väljer du Ladda ned och sparar .zip-paketet lokalt på datorn. Extrahera alla filer från paketet. Du använder dessa filer för att skapa en IoT Edge-modul som innehåller bildklassificeringsservern.

När du nått hit är du klar med att skapa och träna Custom Vision-projektet. Du använder de exporterade filerna i nästa avsnitt, men du är klar med Custom Vision-webbplatsen.

Skapa en IoT Edge-lösning

Nu har du filerna för en containerversion av bildklassificeraren på din utvecklingsdator. I det här avsnittet konfigurerar du bildklassificerarens container till att köras som IoT Edge-modul. Du skapar också en andra modul som distribueras tillsammans med avbildningsklassificeraren. Den andra modulen skickar begäranden till klassificeraren och skickar resultatet som meddelanden till IoT Hub.

Skapa en ny lösning

En lösning är ett logiskt sätt att utveckla och organisera flera moduler för en enskild IoT Edge-distribution. En lösning innehåller kod för en eller flera moduler och distributionsmanifestet som förklarar hur du konfigurerar dem på en IoT Edge-enhet.

I Visual Studio Code väljer du Visa>kommandopalett för att öppna Visual Studio Code-kommandopaletten.

Skriv och kör kommandot Azure IoT Edge: New IoT Edge solution (Ny IoT Edge-lösning) på kommandopaletten. Ange följande information i kommandopaletten för att skapa din lösning:

Fält	Värde
Välj mapp	Välj platsen på utvecklingsdatorn för Visual Studio Code för att skapa lösningsfilerna.
Ange ett namn på lösningen	Ange ett beskrivande namn för lösningen, till exempel CustomVisionSolution, eller acceptera standardnamnet.
Välj modulmall	Välj Python-modul.
Ange ett modulnamn	Ge modulen namnet classifier (klassificerare). Det är viktigt att det här modulnamnet är gemener. IoT Edge är skiftlägeskänsligt när det gäller referenser till moduler, och den här lösningen använder ett bibliotek som formaterar alla begäranden som gemener.
Ange Docker-bildlagringsplats för modulen	En bildlagringsplats innehåller namnet på containerregistret och namnet på containeravbildningen. Containeravbildningen har fyllts i från föregående steg. Ersätt localhost:5000 med värdet för inloggningsservern från azure-containerregistret. Du kan hämta inloggningsservern från sidan Översikt i containerregistret i Azure Portal. Den sista strängen ser ut som registernamn.azurecr.io/classifier>.<

Ange lagringsplatsen för Docker-avbildningen

Visual Studio Code-fönstret läser in arbetsytan för IoT Edge-lösningen.

Lägg till autentiseringsuppgifter för registret

Miljöfilen lagrar autentiseringsuppgifterna för containerregistret och delar dem med körningsmiljön för IoT Edge. Körningen behöver dessa autentiseringsuppgifter för att hämta dina privata avbildningar till IoT Edge-enheten.

IoT Edge-tillägget försöker hämta dina autentiseringsuppgifter för containerregistret från Azure och fyller i dem i miljöfilen. Kontrollera om dina autentiseringsuppgifter redan ingår. Om inte lägger du till dem nu:

Öppna .env-filen i Visual Studio Code-utforskaren.
Uppdatera fälten med det användarnamn och lösenord som du kopierade från Azure Container-registret.
Spara filen.

Kommentar

I den här självstudien används autentiseringsuppgifter för administratörsinloggning för Azure Container Registry, vilket är praktiskt för utvecklings- och testscenarier. När du är redo för produktionsscenarier rekommenderar vi ett alternativ för autentisering med minst privilegier som tjänstens huvudnamn. Mer information finns i Hantera åtkomst till containerregistret.

Välj målarkitektur

Visual Studio Code kan för närvarande utveckla moduler för Linux AMD64- och Linux ARM32v7-enheter. Du måste välja vilken arkitektur du riktar in dig på för varje lösning, eftersom containern skapas och körs på olika sätt för varje arkitekturtyp. Standardvärdet är Linux AMD64, vilket är vad vi använder för den här självstudien.

Öppna kommandopaletten och sök efter Azure IoT Edge: Ange standardmålplattform för Edge-lösning eller välj genvägsikonen i sidofältet längst ned i fönstret.
I kommandopaletten väljer du målarkitekturen i listan med alternativ. I den här självstudien använder vi en virtuell Ubuntu-dator som IoT Edge-enhet, så behåll standardvärdet amd64.

Lägga till bildklassificeraren

Python-modulmallen i Visual Studio Code innehåller exempelkod som du kan köra för att testa IoT Edge. Du använder inte den koden i det här scenariot. Använd i stället stegen i det här avsnittet för att ersätta exempelkoden med den bildklassificerarcontainer som du exporterade tidigare.

I Utforskaren bläddrar du till det Custom Vision-paket som du laddade ned och extraherade. Kopiera allt innehåll från det extraherade paketet. Det bör vara två mappar, app och azureml, och två filer, Dockerfile och README.
I Utforskaren bläddrar du till den katalog där du angav att Visual Studio Code skulle skapa IoT Edge-lösningen.
Öppna mappen för klassificerarmodulen. Om du använde de föreslagna namnen i föregående avsnitt ser mappstrukturen ut så här: CustomVisionSolution/modules/classifier.
Klistra in filerna i mappen classifier.
Återgå till Visual Studio Code-fönstret. Lösningens arbetsyta bör nu visa bildklassificerarfilerna i modulmappen.
Öppna filen module.json i klassificerarens mapp.
Uppdatera plattformsparametern så att den pekar på den nya Dockerfile som du har lagt till och ta bort alla alternativ förutom AMD64, som är den enda arkitektur som vi använder för den här självstudien.
```
"platforms": {
    "amd64": "./Dockerfile"
}
```
Spara dina ändringar.

Skapa en modul med en simulerad kamera

I en verklig Custom Vision-distribution skulle du har en kamera som tillhandahåller livebilder eller videoströmmar. För det här scenariot simulerar du kameran genom att skapa en modul som skickar en testbild till bildklassificeraren.

Lägga till och konfigurera en ny modul

I det här avsnittet lägger du till en ny modul i samma CustomVisionSolution och anger kod för att skapa den simulerade kameran.

I samma Visual Studio Code-fönster använder du kommandopaletten för att köra Azure IoT Edge: Lägg till IoT Edge-modul. I kommandopaletten anger du följande information för den nya modulen:

Prompt	Värde
Välj distributionsmallfil	Välj filen deployment.template.json i mappen CustomVisionSolution.
Välj modulmall	Välj Python-modul
Ange ett modulnamn	Ge modulen namnet cameraCapture
Ange Docker-bildlagringsplats för modulen	Ersätt localhost:5000 med värdet för inloggningsservern för azure-containerregistret. Den slutgiltiga strängen ser ut så här: <registernamn>.azurecr.io/cameracapture.

Visual Studio Code-fönstret läser in den nya modulen på lösningsarbetsytan och uppdaterar deployment.template.json-filen. Nu bör du se två modulmappar: classifier och cameraCapture.

Öppna filen main.py fil i mappen modules / cameraCapture.

Ersätt hela filen med följande kod. Den här exempelkoden skickar POST-begäranden till den bildbearbetningstjänst som körs i klassificerarmodulen. Vi förser den här modulcontainern med en exempelbild som ska användas i begärandena. Sedan paketerar den svaret som IoT Hub-meddelande och skickar det till en utdatakö.

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

Spara filen main.py.
Öppna filen requirements.txt .
Lägg till en ny rad för ett bibliotek som ska inkluderas i containern.
```
requests
```
Spara filen requirements.txt.

Lägga till en testbild i containern

I stället för att använda en verklig kamera för att ge en bildfeed för det här scenariot använder vi en enskild testbild. En testbild ingår i den GitHub-lagringsplats som du laddade ned för träningsbilderna tidigare i självstudien.

Gå till testbilden, som finns på Cognitive-CustomVision-Windows / Samples / Images / Test.
Kopiera test_image.jpg
Bläddra till katalogen för IoT Edge-lösningen och klistra in testbilden i mappen modules / cameraCapture. Bilden ska vara i samma mapp som filen main.py, som du redigerade i föregående avsnitt.
I Visual Studio Code öppnar du filen Dockerfile.amd64 för modulen cameraCapture.
Efter den rad som upprättar arbetskatalogen, WORKDIR /app, lägger du till följande kodrad:
```
ADD ./test_image.jpg .
```
Spara Dockerfile.

Förbereda ett distributionsmanifest

Hittills i den här självstudien har du tränat en Custom Vision-modell att klassificera bilder av träd och paketerat modellen som IoT Edge-modul. Sedan skapade du en andra modul som kan köra frågor mot bildklassificeringsservern och rapporterar resultatet tillbaka till IoT Hub. Nu är du redo att skapa det distributionsmanifest som talar om för en IoT Edge-enhet hur de här två modulerna ska startas och köras tillsammans.

IoT Edge-tillägget för Visual Studio Code innehåller en mall i varje IoT Edge-lösning som hjälper dig skapa ett distributionsmanifest.

Öppna filen deployment.template.json i lösningsmappen.
Leta reda på avsnittet moduler , som ska innehålla tre moduler: de två som du skapade, klassificeraren och cameraCapture, och en tredje som ingår som standard, SimulatedTemperatureSensor.
Ta bort modulen SimulatedTemperatureSensor med alla dess parametrar. Den här modulen ingår för att tillhandahålla exempeldata för testscenarier, men den behövs inte i den här distributionen.
Om du har gett bildklassificeringsmodulen något annat namn än classifier kontrollerar du namnet nu och ser till att det endast består av gemener. Modulen cameraCapture anropar klassificerarmodulen med hjälp av ett begärandebibliotek som formaterar alla begäranden med gemener, och IoT Edge är skiftlägeskänsligt.
Uppdatera parametern createOptions för modulen cameraCapture med följande JSON. Den här informationen skapar miljövariabler i modulcontainern som hämtas i main.py-processen. Genom att inkludera den här informationen i distributionsmanifestet kan du ändra bild eller slutpunkt utan att behöva återskapa modulbilden.
```
"createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
```
Om du gav Custom Vision-modulen något annat namn än classifier uppdaterar du slutpunktsvärdet för bildbearbetning så att det matchar.
Längst ned i filen uppdaterar du parametern routes för modulen $edgeHub. Du behöver dirigera förutsägelseresultaten från cameraCapture till IoT Hub.
```
    "routes": {
      "cameraCaptureToIoTHub": "FROM /messages/modules/cameraCapture/outputs/* INTO $upstream"
    },
```
Om du gav den andra modulen något annat namn än cameraCapture uppdaterar du vägvärdet så att det matchar.
Spara filen deployment.template.json.

Skapa och push-överföra din IoT Edge-lösning

Nu när båda modulerna har skapat s och distributionsmanifestmallen har konfigurerats är du redo att skapa containerbilderna och överföra dem till containerregistret.

När bilderna finns i registret kan du distribuera lösningen till en IoT Edge-enhet. Du kan ange moduler på en enhet via IoT Hub, men du kan också komma åt din IoT Hub och enheter via Visual Studio Code. I det här avsnittet konfigurerar du åtkomst till din IoT Hub och använder sedan Visual Studio Code för att distribuera din lösning till din IoT Edge-enhet.

Först skapar och överför du lösningen till ditt containerregister.

Öppna den integrerade Terminalen i Visual Studio Code genom att välja Visa>terminal.
Logga in på Docker genom att ange följande kommando i terminalen. Logga in med användarnamnet, lösenordet och inloggningsservern från azure-containerregistret. Du kan hämta dessa värden från avsnittet Åtkomstnycklar i registret i Azure Portal.
```
docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Du kan få en säkerhetsvarning som rekommenderar användning av --password-stdin. Även om den bästa metoden rekommenderas för produktionsscenarier ligger den utanför omfånget för den här självstudien. Mer information finns i docker-inloggningsreferensen.
I Visual Studio Code-utforskaren högerklickar du på filen deployment.template.json och väljer Build and Push IoT Edge solution (Skapa och push-lösning för IoT Edge).

Kommandot build och push startar tre åtgärder. Först skapar den en ny mapp i lösningen med namnet config som innehåller det fullständiga distributionsmanifestet, som är inbyggt med information i distributionsmallen och andra lösningsfiler. För det andra körs docker build den för att skapa containeravbildningen baserat på lämplig dockerfile för målarkitekturen. Sedan körs docker push den för att skicka avbildningslagringsplatsen till containerregistret.

Den här processen kan ta flera minuter första gången, men det går snabbare nästa gång du kör kommandona.

Distribuera moduler till enheten

Använd Visual Studio Code-utforskaren och Azure IoT Edge-tillägget för att distribuera modulprojektet till din IoT Edge-enhet. Du har redan ett distributionsmanifest förberett för ditt scenario, den deployment.amd64.json filen i mappen config. Allt du behöver göra nu är att välja en enhet som ska ta emot distributionen.

Kontrollera att din IoT Edge-enhet är igång.

I Visual Studio Code-utforskaren under avsnittet Azure IoT Hub expanderar du Enheter för att se din lista över IoT-enheter.
Högerklicka på namnet för din IoT Edge-enhet och välj sedan Create Deployment for Single Device (Skapa distribution för en enskild enhet).
Välj filen deployment.amd64.json i mappen config och välj sedan Distributionsmanifest för Edge. Använd inte filen deployment.template.json.
Under enheten expanderar du Moduler för att se en lista över distribuerade och körande moduler. Välj uppdateringsknappen. Du bör se de nya modulerna klassificerare och kameraKapsling som körs tillsammans med $edgeAgent och $edgeHub.

Du kan även kontrollera att alla moduler är igång på själva enheten. Kör följande kommando på IoT Edge-enheten för att se status för modulerna.

iotedge list

Det kan ta några minuter innan modulerna startas. IoT Edge-körningen måste ta emot sitt nya distributionsmanifest, hämta modulavbildningarna från containerkörningen och starta sedan varje ny modul.

Visa klassificeringsresultat

Det finns två sätt att visa resultatet från modulerna, antingen på själva enheten allt eftersom meddelandena genereras och skickas, eller från Visual Studio Code när meddelandena kommer till IoT Hub.

Från enheten visar du loggarna för modulen cameraCapture för att se meddelandena skickas och bekräftelsen att de togs emot av IoT Hub.

iotedge logs cameraCapture

Du bör till exempel se utdata som följande:

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

Du kan också visa meddelanden från Visual Studio Code. Högerklicka på namnet på din IoT Edge-enhet och välj Starta övervakning inbyggd händelseslutpunkt.

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

Kommentar

Inledningsvis kan du se anslutningsfel i utdata från cameraCapture-modulen. Detta beror på fördröjningen mellan moduler som distribueras och startar.

CameraCapture-modulen försöker automatiskt ansluta igen tills den lyckas. När anslutningen har slutförts visas de förväntade bildklassificeringsmeddelandena.

Resultaten från Custom Vision-modulen som skickas som meddelanden från cameraCapture-modulen inkluderar sannolikheten att bilden är av antingen ett hemlock eller körsbärsträd. Eftersom bilden föreställer en hemlockgran bör du se sannolikheten 1.0.

Rensa resurser

Om du tänker fortsätta till nästa rekommenderade artikel kan du behålla de resurser och konfigurationer du har skapat och använda dem igen. Du kan även fortsätta att använda samma IoT Edge-enhet som en testenhet.

Annars kan du ta bort de lokala konfigurationer och Azure-resurser som du använde i den här artikeln för att undvika avgifter.

Ta bort Azure-resurser

Det går inte att ångra borttagningen av Azure-resurser och resursgrupper. Var noga så att du inte tar bort fel resursgrupp eller resurser av misstag. Om du har skapat IoT-hubben i en befintlig resursgrupp som har resurser som du vill behålla tar du bara bort själva IoT Hub-resursen, inte resursgruppen.

Ta bort resurser:

Logga in på Azure-portalen och välj Resursgrupper.
Välj namnet på resursgruppen som innehåller dina IoT Edge-testresurser.
Granska listan över resurser som resursgruppen innehåller. Om du vill ta bort alla kan du välja Ta bort resursgrupp. Om du bara vill ta bort några av dem kan du välja varje resurs för att ta bort dem individuellt.

Nästa steg

I den här självstudien tränade du en Custom Vision-modell och distribuerade den som modul till en IoT Edge-enhet. Sedan skapade du en modul som kan köra frågor mot bildklassificeringstjänsten och rapporterar resultatet tillbaka till IoT Hub.

Fortsätt till nästa självstudier för att lära dig mer om andra sätt som Azure IoT Edge kan hjälpa dig att omvandla data till affärsinsikter på gränsen.

Lagra data på gränsen med SQL Server-databaser

Dela via