Oktatóanyag: Képosztályozás végrehajtása a peremhálózaton a Custom Vision Service használatával

A következőre vonatkozik:IoT Edge 1.5 jelölés IoT Edge 1.5

Fontos

IoT Edge 1.5 LTS a támogatott kiadás. IoT Edge 1,4 LTS 2024. november 12-én véget ért. Ha korábbi kiadást használ, tekintse meg a Update IoT Edge című témakört.

Azure IoT Edge hatékonyabbá teszi az IoT-megoldásokat a számítási feladatok felhőből a peremhálózatra való áthelyezésével. Ez a képesség kiválóan alkalmas olyan szolgáltatásokra, amelyek nagy mennyiségű adatot dolgoznak fel, például számítógépes látásmodelleket. Azure AI Custom Vision lehetővé teszi egyéni képosztályozók készítését és tárolóként való üzembe helyezését az eszközökön. Ez a két szolgáltatás együttesen lehetővé teszi a felhasználók számára, hogy képekből vagy videostreamekből származó megállapításokat találjanak anélkül, hogy az összes adatot a helyszínen kívülre továbbítanák. A Custom Vision egy osztályozót biztosít, amely összehasonlítja a képeket egy betanított modellel az elemzések létrehozásához.

A Custom Vision például egy IoT Edge eszközön meghatározhatja, hogy egy autópályán a szokásosnál nagyobb vagy alacsonyabb a forgalom, vagy hogy egy parkolóházban vannak-e rendelkezésre álló parkolóhelyek egy sorban. Ezeket a megállapításokat műveletvégzés céljából meg lehet osztani egy másik eszközzel.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

  • Képosztályozó létrehozása a Custom Vision használatával.
  • Dolgozzon ki egy IoT Edge modult, amely lekérdezi a Custom Vision webkiszolgálót az eszközön.
  • Küldje el a képosztályozó eredményeit a IoT Hub.

Diagram – Oktatóanyag-architektúra, fázis- és üzembe helyezési osztályozó

Ha nincs Azure fiókja, a kezdés előtt hozzon létre egy felszabadító fiókot.

Előfeltételek

Tipp

Ez az oktatóanyag a Custom Vision és Azure IoT Edge egy Raspberry Pi 3 mintaprojekt egyszerűsített verziója. Felhőbeli virtuális gépen fut, és statikus rendszerképek használatával tanítja be és teszteli a képosztályozót, ami segít a Custom Vision új felhasználóinak a IoT Edge. A mintaprojekt fizikai hardvert használ, és beállít egy élő kameracsatornát a képosztályozó betanításához és teszteléséhez, ami hasznos lehet egy részletesebb, valós forgatókönyvet feltáró személy számára.

Képosztályozó létrehozása a Custom Vision használatával

Képosztályozó létrehozásához hozzon létre egy Custom Vision-projektet, és biztosítson betanítási képeket. A szakaszban elvégezhető lépésekkel kapcsolatos további információkért tekintse meg az Osztályozó létrehozása a Custom Vision használatával című cikket.

A képosztályozó létrehozása és betanítása után exportálja Docker-tárolóként, és helyezze üzembe egy IoT Edge eszközön.

Új projekt létrehozása

  1. A webböngészőben lépjen a Custom Vision weblapjára.

  2. Válassza a Sign in lehetőséget, és jelentkezzen be ugyanazzal a fiókkal, amelyet Azure erőforrások eléréséhez használ.

  3. Válassza az Új projekt lehetőséget.

  4. Hozza létre a projektet az alábbi értékekkel:

    Mező Érték
    Név Adja meg a projekt nevét, például az EdgeTreeClassifier nevet.
    Leírás Választható projektleírás.
    Erőforrás Válasszon egy Azure erőforráscsoportot, amely tartalmaz egy Custom Vision Service erőforrást, vagy hozzon létre újat, ha még nem adott hozzá egyet.
    Projekttípusok Besorolás
    Osztályozási típusok Multiclass (single tag per image) (Multiclass (egyetlen címke képenként))
    Tartományok General (compact) (Általános (kompakt))
    Exportálási képességek Alapszintű platformok (TensorFlow, CoreML, ONNX, ...)

  5. Válassza a Projekt létrehozása lehetőséget.

Képek feltöltése és az osztályozó betanítása

A képosztályozó létrehozásához betanítási és tesztelési képekre van szükség.

  1. Klónozza vagy töltse le a mintaképeket a Cognitive-CustomVision-Windows adattárból a helyi fejlesztőgépre.

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

  2. Térjen vissza a Custom Vision-projekthez, és válassza az Add images (Képek hozzáadása) lehetőséget.

  3. Keresse meg a helyileg klónozott git-adattárat, és keresse meg az első képmappát, Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Jelölje ki a mappában lévő mind a 10 képet, majd válassza a Megnyitás lehetőséget.

  4. Adja hozzá a címke hemlockját ehhez a képcsoporthoz, majd nyomja le az Enter billentyűt a címke alkalmazásához.

  5. Válassza az Upload 10 files (10 fájl feltöltése) lehetőséget.

    Hemlock címkével ellátott fájlok feltöltése a Custom Visionbe

  6. Amikor a képek feltöltése sikeresen befejeződött, válassza a Done (Kész) lehetőséget.

  7. Ismét válassza az Add images (Képek hozzáadása) lehetőséget.

  8. Keresse meg a második képmappát, Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Válassza ki a mappában található 10 képet, majd válassza az Open lehetőséget.

  9. Adja hozzá a japanese cherry (japán cseresznye) címkét ehhez a képcsoporthoz, és nyomja le az enter billentyűt a címke alkalmazásához.

  10. Válassza az Upload 10 files (10 fájl feltöltése) lehetőséget. Amikor a képek feltöltése sikeresen befejeződött, válassza a Done (Kész) lehetőséget.

  11. Mindkét képkészlet címkézése és feltöltése után válassza a Betanítás lehetőséget az osztályozó betanításához.

Az osztályozó exportálása

  1. Az osztályozó betanítását követően válassza az Export (Exportálás) lehetőséget az osztályozó Performance (Teljesítmény) lapján.

    A betanított képosztályozó exportálása

  2. Platformként válassza a DockerFile lehetőséget.

  3. A verzió megadásakor válassza a Linux lehetőséget.

  4. Válassza Exportáláslehetőséget.

  5. Az exportálás befejezése után válassza a Letöltés lehetőséget, és mentse a .zip csomagot helyileg a számítógépre. Bontsa ki a fájlokat a csomagból. Ezekkel a fájlokkal létrehozhat egy IoT Edge modult, amely tartalmazza a képosztályozási kiszolgálót.

Ha elérte ezt a pontot, befejezte a Custom Vision-projekt létrehozását és betanítását. Az exportált fájlokat a következő szakaszban használhatja, a Custom Vision weblappal azonban már elkészült.

IoT Edge-megoldás létrehozása

Most már rendelkezik a képosztályozó tárolóverziójának fájljaival a fejlesztői gépen. Ebben a szakaszban beállítja a képosztályozó tárolót, hogy IoT Edge modulként fusson. Egy második modult is létrehoz, amely a kérelmeket közzéteszi az osztályozónak, és üzenetekként küldi el az eredményeket IoT Hub.

Új megoldás létrehozása

A megoldás logikai módszer több modul fejlesztésére és rendszerezésére egyetlen IoT Edge üzembe helyezéshez. Egy megoldás egy vagy több modul kódját és az üzembe helyezési jegyzéket tartalmazza, amely deklarálja, hogyan konfigurálhatja őket egy IoT Edge eszközön. Hozza létre a megoldást a Azure IoT Edge Fejlesztői eszköz parancssori fejlesztőeszköz használatával. Az eszköz használatának legegyszerűbb módja a A IoT Edge Dev Container futtatása a Dockerrel.

  1. Hozzon létre egy osztályozó nevű könyvtárat, és váltson a könyvtárra.

    mkdir CustomVisionSolution
cd CustomVisionSolution

  2. Futtassa a iotedgedev eszköz init parancsát egy új IoT Edge megoldás létrehozásához. A IoT Edge Dev Docker-tárolóban adja meg a következő parancsot:

    iotedgedev solution init --template python --module classifier

    Az iotedgedev megoldás init szkriptje több lépés elvégzését kéri, például:

    • Hitelesítés az Azure-hoz
    • Azure-előfizetés kiválasztása
    • Erőforráscsoport kiválasztása vagy létrehozása
    • Azure IoT Hub kiválasztása vagy létrehozása
    • Azure IoT Edge eszköz kiválasztása vagy létrehozása

    A parancs létrehoz egy új IoT Edge megoldást egy classifier nevű modullal az aktuális munkakönyvtárban.

  3. Nyissa meg a projektet a Visual Studio Code-ban.

A képosztályozó hozzáadása

A Visual Studio Code Python modulsablonja tartalmaz néhány mintakódot, amelyet a IoT Edge teszteléséhez futtathat. Ebben a forgatókönyvben ezt a kódot nem fogja használni. Helyette a jelen szakaszban leírt lépésekkel cserélje le a mintakódot a korábban exportált képosztályozó-tárolóra.

  1. A fájlkezelőben tallózással keresse meg a letöltött és kibontott Custom Vision-csomagot. Másolja a tartalmakat a kibontott csomagból. Ez az app és az azureml mappákat, valamint a Dockerfile és a README fájlokat jelenti.

  2. A fájlkezelőben keresse meg azt a könyvtárat, amelyben azt mondta Visual Studio Code, hogy hozza létre a IoT Edge megoldást.

  3. Nyissa meg az osztályozó modulmappáját. Ha az előző szakaszban a javasolt értékeket használta, a mappastruktúrának a következőhöz hasonlóan kell kinéznie: CustomVisionSolution / modules / classifier.

  4. Helyezze a fájlokat a classifier mappába.

  5. Térjen vissza a Visual Studio Code ablakhoz. A megoldás munkaterületének most a modulmappában található képosztályozó-fájlokat kell mutatnia.

  6. Cserélje le az eredeti Dockerfile.amd64 fájlt a Custom Vision-csomagból származó Dockerfile fájllal, azáltal, hogy törli az eredeti Dockerfile.amd64 fájlt, majd a Dockerfile fájlt átnevezi Dockerfile.amd64 fájlra.

  7. Mentse a módosításokat.

Szimulált kameramodul létrehozása

Egy valós egyéni látásmódú üzembe helyezés során a kamera élő képeket vagy videostreameket biztosít. Ebben a forgatókönyvben szimulálhatja a kamerát egy olyan modul létrehozásával, amely egy tesztképet küld a képosztályozónak.

Ebben a szakaszban hozzáadhatja az új modult a meglévő CustomVisionSolution megoldáshoz, és létrehozhatja a kóddal a szimulált kamerát.

  1. Az iotedgedev eszközzel adjon hozzá egy új modult a megoldáshoz. A parancs létrehoz egy cameracapture nevű új mappát a megoldás modulok mappájában.

    iotedgedev solution add --template python cameracapture

  2. Nyissa meg a main.py fájlt a modulok / cameracapture mappájában.

  3. Cserélje le a teljes fájlt az alábbi kódra. A mintakód POST kéréseket küld az osztályozómodulban futó rendszerkép-feldolgozó szolgáltatásnak. Ehhez a modultárolóhoz adjon hozzá egy mintaképet, amelyet a modultároló a kérésekben fog használni. Ezután IoT Hub üzenetként csomagolja a választ, és elküldi egy kimeneti üzenetsorba.

    # 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. Mentse a main.py fájlt.

  5. Nyissa meg a requirements.txt fájlt.

  6. Adjon hozzá egy új sort, amellyel egy könyvtárat lehet beilleszteni a tárolóba.

    requests

  7. Mentse a requirements.txt fájlt.

Tesztkép hozzáadása a tárolóhoz

Ebben a forgatókönyvben ahelyett, hogy valódi kamerát használnánk egy képcsatorna biztosításához, egyetlen tesztképet használunk. Az oktatóanyag korábbi részében a betanítási képekhez letöltött GitHub adattár tartalmaz egy tesztképet.

  1. Navigáljon a tesztképhez, Cognitive-CustomVision-Windows / Samples / Images / Test címen található.

  2. Másolja a test_image.jpg fájlt

  3. Keresse meg a IoT Edge megoldáskönyvtárat, és illessze be a tesztképet a modules / cameracapture mappába. A képnek ugyanabban a mappában kell lennie, mint ahol az előző szakaszban szerkesztett main.py fájl található.

  4. A(z) Visual Studio Code-ban nyissa meg a Dockerfile.amd64 fájlt a cameracapture modulhoz.

  5. A WORKDIR /app munkakönyvtárat létrehozó sor után adja hozzá az alábbi kódsort:

    ADD ./test_image.jpg .

  6. Mentse a Dockerfile-t.

Üzembehelyezési jegyzék előkészítése

Ebben az oktatóanyagban eddig betanított egy egyéni látásmodellt a fák képeinek besorolására, majd ezt a modellt egy IoT Edge modulba csomagolt. Ezután létrehozott egy második modult, amely lekérdezi a rendszerkép-besorolási kiszolgálót, és jelentést készít az eredményekről IoT Hub. Most már készen áll az üzembe helyezési jegyzék létrehozására, amely tájékoztatja egy IoT Edge eszközt, hogyan indíthatja el és futtathatja együtt ezt a két modult.

A Visual Studio Code IoT Edge bővítménye minden IoT Edge megoldásban tartalmaz egy sablont, amely segít létrehozni egy üzembehelyezési jegyzéket.

  1. Nyissa meg a deployment.template.json fájlt a megoldás mappájában.

  2. Állítsa be a regisztrációs adatbázis hitelesítő adatait a modulokhoz az üzembe helyezési jegyzékben.

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

    Cserélje le a <registryName> elemet a Azure tárolóregisztrációs adatbázis nevére, és cserélje le a <AcrUsername> és <AcrPassword> a regisztrációs adatbázis felhasználónevét és jelszavát. Ezeket az értékeket a Azure tárolóregisztrációs adatbázis Access kulcsok szakaszában találja a Azure portálon.

  3. Keresse meg a modulok szakaszt, amely három modult tartalmaz: a létrehozott kettőt, az osztályozót és a kamerakészletet, a harmadikat pedig alapértelmezés szerint a tempSensor tartalmazza.

  4. Törölje a tempSensor modult az összes paraméterével. Ez a modul mintaadatokat biztosít a tesztforgatókönyvekhez, de ebben az üzembe helyezésben nincs rá szükség.

  5. Ha a képosztályozó modulnak nem a classifier nevet adta, ellenőrizze a nevet, és győződjön meg arról, hogy csak kisbetűket tartalmaz. A cameracapture modul egy kérelemtár használatával hívja meg az osztályozó modult, amely kisbetűs formátumban formázza az összes kérést, és IoT Edge megkülönbözteti a kis- és nagybetűket.

  6. Minden rendszermodul edgeAgent és edgeHub esetében módosítsa a createOptions értékét sztringezett verzióra. Például:

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

  7. Minden rendszermodul edgeAgent és edgeHub esetében módosítsa a rendszerkép verzióját a legújabb 1.5-ös verzióra. Például:

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

  8. Frissítse az osztályozó modul createOptions paraméterét egy sztringezett verzióra. Például:

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

  9. Frissítse a cameracapture modul createOptions paraméterét a következő JSON-val. Ez az információ olyan környezeti változókat hoz létre a modultárolóban, amelyek a main.py folyamatban vannak lekérve. Az üzembehelyezési jegyzékben szereplő információk segítségével a rendszerképet vagy a végpontot a modul lemezképének újraépítése nélkül módosíthatja.

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

    Ha a Custom Vision-modulnak nem a classifier nevet adta, frissítse úgy a képfeldolgozó végpont értékét, hogy megegyezzen a modul nevével.

    Az osztályozó és a kameralap konfigurációjának például a következőhöz hasonlónak kell lennie:

    "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. Mentse a deployment.template.json fájlt.

Az IoT Edge megoldás létrehozása és feltöltése

Miután létrehozta mindkét modult, és konfigurálta az üzembehelyezési jegyzéksablont, hozza létre a tárolólemezképeket, és küldje el őket a tárolóregisztrációs adatbázisba.

Miután a rendszerképek a beállításjegyzékben vannak, üzembe helyezheti a megoldást egy IoT Edge eszközön. Az eszközön a modulokat a IoT Hub keresztül állíthatja be. Ebben a szakaszban beállítja a IoT Hub való hozzáférést, majd a Azure CLI használatával helyezi üzembe a megoldást az IoT Edge eszközén.

Először hozza létre és küldje le a megoldást a tárolóregisztrációs adatbázisba.

  1. Nyissa meg a Visual Studio Code integrált terminált a View>Terminal kiválasztásával.

  2. Jelentkezzen be a Dockerbe a következő parancs beírásával a terminálban a felhasználónév, a jelszó és a bejelentkezési kiszolgáló használatával a Azure tárolóregisztrációs adatbázisból. Ezeket az értékeket lekérheti a beállításjegyzék Access kulcsok szakaszából a Azure portálon.

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

    Előfordulhat, hogy biztonsági figyelmeztetést kap, amely a használatát --password-stdinjavasolja. Bár ezt az eljárást gyártási környezetekhez ajánljuk, az oktatóanyag hatókörén kívül esik. További információkért tekintse meg a Docker bejelentkezési referenciát.

  3. A modul Docker-lemezképének létrehozásához és címkézéséhez használja a modul Docker-fájlját.

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

    Ha például a rendszerképet a helyi beállításjegyzékhez vagy egy Azure tárolóregisztrációs adatbázishoz szeretné létrehozni, használja a következő parancsokat:

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

Push modul Docker-képje

Adja meg a tárolóregisztrációs adatbázis hitelesítő adatait a Dockernek, hogy az le tudja küldeni a tárolólemezképet a tárolóregisztrációs adatbázisban lévő tárolóba.

  1. Jelentkezzen be a Dockerbe az Azure Container Registry (ACR) hitelesítő adataival.

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

    Előfordulhat, hogy biztonsági figyelmeztetést kap, amely a használatát --password-stdinjavasolja. Bár ez az ajánlott legjobb gyakorlat éles forgatókönyvekhez, túlmutat ennek az oktatóanyagnak a hatókörén. További információkért tekintse meg a Docker bejelentkezési referenciát.

  2. Jelentkezzen be az Azure Container Registry-be. A parancs használatához az kell használnia. Ez a parancs a konténer-regisztrációs adatbázisban található felhasználónevet és jelszót kéri, amelyet a Beállítások>Access keys részben talál.

    az acr login -n <AcrRegistryName>

    Tipp

    Ha az oktatóanyag bármely pontján kijelentkezik, ismételje meg a Docker és az Azure Container Registry bejelentkezési lépéseit a folytatáshoz.

  3. Küldje el a modul rendszerképét a helyi beállításjegyzékbe vagy egy tárolóregisztrációs adatbázisba.

    docker push <ImageName>

    Például:

    # 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

Az üzembehelyezési sablon frissítése

Frissítse a deployment.template.json fájlt a tárolóregisztrációs adatbázis lemezképének helyével. Módosítsa a rendszerkép értékét a beállításjegyzékbe leküldett képre. Például cserélje le a <AcrRegistryName> nevet a saját beállításjegyzék nevére az osztályozó és a cameracapture modulok képadatain.

"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\"]}"
        }
    }
}

A végső üzembehelyezési jegyzék a következőhöz hasonlóan néz ki:

{
  "$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
        }
      }
    }
  }
}

Modulok üzembe helyezése az eszközön

Ellenőrizze, hogy a beépített tárolólemezképek a tárolóregisztrációs adatbázisban vannak-e tárolva. Ezután helyezze üzembe őket egy eszközön a forgatókönyvhöz előkészített üzembehelyezési jegyzék deployment.template.json használatával.

A IoT Edge Azure CLI set-modules paranccsal telepítse a modulokat az Azure IoT Hubra. A deployment.template.json fájlban definiált modulokat például az IoT Hub <IotHubName> alá tartozó <DeviceName> IoT Edge eszközre a következő parancs használatával telepítheti. Cserélje le a hub-name, device-id és login IoT Hub connection string értékeit a saját értékére.

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

Tipp

Az Azure portálon megtalálhatja az IoT Hub kapcsolati karakterláncát, beleértve a megosztott hozzáférési kulcsot is. Nyissa meg a IoT Hub >Security settings>Shared access policies>iothubowner.

Győződjön meg arról, hogy a IoT Edge eszköz fut.

Az eszköz alatt bontsa ki a Modulok elemet az üzembe helyezett és a futó modulok listájának megtekintéséhez. Válassza a frissítés gombot. Az új osztályozó és kamerarögzítő modulok a $edgeAgent és $edgeHub együtt futnak.

Azt is ellenőrizheti, hogy működik-e az összes modul magán az eszközön. Az IoT Edge eszközön futtassa a következő parancsot a modulok állapotának megtekintéséhez.

iotedge list

A modulok elindítása eltarthat néhány percig. A IoT Edge futtatókörnyezetnek meg kell kapnia az új üzembehelyezési jegyzékfájlt, le kell húznia a modul lemezképeit a tároló futtatókörnyezetéből, majd el kell indítania minden új modult.

Osztályozási eredmények megtekintése

Az eszközön tekintse meg a cameracapture modul naplóit az elküldött üzenetek megtekintéséhez, és győződjön meg arról, hogy IoT Hub fogadták őket.

iotedge logs cameracapture

Például a következőhöz hasonló kimenetnek kell megjelennie:

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

Megjegyzés

Kezdetben csatlakozási hibák jelentkezhetnek a kamerakészlet modul kimenetében az üzembe helyezett és az indítási modulok közötti késés miatt.

A cameracapture modul automatikusan újra megismétli a kapcsolatot, amíg sikeres nem lesz. A sikeres csatlakozás után megjelennek a várt képbesorolási üzenetek.

A CameraCapture modul üzenetként küldött Custom Vision modul eredményei tartalmazzák annak a valószínűségét, hogy a kép hemlock vagy cseresznyefa. Mivel a kép borsikafű, úgy látod, hogy a valószínűség 1,0.

Az erőforrások megtisztítása

Ha folytatni szeretné a következő ajánlott cikket, tartsa meg a létrehozott erőforrásokat és konfigurációkat, és használja újra őket. Azt is megteheti, hogy ugyanazt a IoT Edge eszközt használja, mint egy teszteszközt.

Ellenkező esetben törölje a helyi konfigurációkat és a cikkben használt Azure erőforrásokat a díjak elkerülése érdekében.

Azure-erőforrások törlése

Nem vonhatja vissza Azure erőforrások és erőforráscsoportok törlését. Figyeljen, nehogy véletlenül rossz erőforráscsoportot vagy erőforrásokat töröljön. Ha a IoT Hub egy meglévő erőforráscsoporton belül hozta létre, amelyben meg szeretné tartani az erőforrásokat, csak magát a IoT Hub erőforrást törölje, ne az erőforráscsoportot.

Az erőforrások törlése:

  1. Jelentkezzen be a Azure portálra, majd válassza a Csoportokat.
  2. Válassza ki a IoT Edge teszterőforrásokat tartalmazó erőforráscsoport nevét.
  3. Tekintse át az erőforráscsoport által tartalmazott erőforrások listáját. Ha mindet törölni szeretné, válassza az Erőforráscsoport törlése lehetőséget. Ha csak néhányat szeretne törölni, jelölje ki az egyes erőforrásokat, hogy egyenként törölje őket.

Következő lépések

Ebben az oktatóanyagban betanított egy Custom Vision-modellt, és modulként üzembe helyezte azt egy IoT Edge eszközön. Ezután létrehozott egy modult, amely lekérdezheti a képbesorolási szolgáltatást, és jelentést készíthet az eredményekről IoT Hub.

Folytassa a következő oktatóanyagokkal, hogy megismerje azokat a módszereket, amelyekkel Azure IoT Edge segíthet az adatok üzleti elemzésekké alakításában a peremhálózaton.

Azure IoT Edge modulok fejlesztése a Visual Studio Code használatával

  • Last updated on