Návod: Provádění klasifikace obrázků na okraji s využitím služby Custom Vision

Použitelné pro:IoT Edge 1.5 zaškrtnuto IoT Edge 1.5

Důležité

IoT Edge 1.5 LTS je podporovaná verze. IoT Edge 1,4 LTS dosáhl konce životnosti 12. listopadu 2024. Pokud používáte starší verzi, přečtěte si téma Update IoT Edge.

Azure IoT Edge zefektivňuje řešení IoT tím, že přesouvá úlohy z cloudu na hranu. Tato schopnost se dobře hodí ke službám, které zpracovávají velké objemy dat, jako jsou modely počítačového zpracování obrazu. Azure AI Custom Vision umožňuje vytvářet vlastní klasifikátory imagí a nasazovat je do zařízení jako kontejnery. Tyto dvě služby umožňují uživatelům najít přehledy z obrázků nebo datových proudů videa, aniž by nejprve přenášeli všechna data mimo pracoviště. Custom Vision poskytuje klasifikátor, který porovnává obrázky s natrénovaným modelem za účelem generování přehledů.

Služba Custom Vision na zařízení IoT Edge může například určit, jestli má dálnice vyšší nebo nižší provoz než normální, nebo jestli má parkovací garáž k dispozici parkovací místa v řadě. Tyto přehledy je možné sdílet s jinou službou, která na ně může reagovat.

V tomto kurzu se naučíte:

  • Vytvoření klasifikátoru obrázků s využitím služby Custom Vision
  • Vyvíjejte modul IoT Edge, který na zařízení dotazuje webový server Custom Vision.
  • Odešlete výsledky klasifikátoru obrázků do IoT Hub.

Diagram – architektura kurzu, fáze a nasazení klasifikátoru

Pokud účet Azure nemáte, vytvořte si účet free než začnete.

Požadavky

Návod

Tento kurz je zjednodušená verze Custom Vision a Azure IoT Edge na ukázkovém projektu Raspberry Pi 3. Běží na cloudovém virtuálním počítači a používá statické obrázky k trénování a otestování klasifikátoru obrázků, který pomáhá někomu novému ve službě Custom Vision na IoT Edge. Ukázkový projekt používá fyzický hardware a nastavuje živý přenos kamery pro trénování a testování klasifikátoru obrázků, což je užitečné pro někoho, kdo zkoumá podrobnější scénáře v reálném prostředí.

Vytvoření klasifikátoru obrázků s využitím služby Custom Vision

Pokud chcete vytvořit klasifikátor obrázků, vytvořte projekt Custom Vision a poskytněte trénovací obrázky. Další informace o krocích, které provedete v této části, najdete v tématu Postup vytvoření klasifikátoru s využitím služby Custom Vision.

Po sestavení a trénování klasifikátoru image ho exportujte jako kontejner Dockeru a nasaďte ho do IoT Edge zařízení.

Vytvoření nového projektu

  1. Ve webovém prohlížeči přejděte na webovou stránku služby Custom Vision.

  2. Vyberte Sign in a přihlaste se pomocí stejného účtu, který používáte pro přístup k prostředkům Azure.

  3. Vyberte Nový projekt.

  4. Vytvořte projekt s použitím následujících hodnot:

    Pole Hodnota
    Název Zadejte název projektu, například EdgeTreeClassifier.
    Popis Volitelný popis projektu.
    Prostředek Vyberte jednu z vašich Azure skupin prostředků, které zahrnují prostředek služby Custom Vision Service nebo vytvřete nový pokud jste ho ještě nepřidali.
    Typy projektů klasifikace
    Typy klasifikace Více tříd (jedna značka na obrázek)
    Domény Obecné (kompaktní)
    Možnosti exportu Základní platformy (TensorFlow, CoreML, ONNX, ...)

  5. Vyberte příkaz Vytvořit projekt.

Nahrání obrázků a trénování klasifikátoru

Vytvoření klasifikátoru obrázků vyžaduje sadu trénovacích obrázků a testovacích obrázků.

  1. Naklonujte nebo stáhněte ukázkové obrázky z úložiště Cognitive-CustomVision-Windows do místního vývojového počítače.

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

  2. Vraťte se ke svému projektu služby Custom Vision a vyberte Přidat obrázky.

  3. Přejděte do úložiště Git, které jste naklonovali místně, a přejděte do první složky obrázku Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Vyberte všech 10 obrázků ve složce a pak vyberte Otevřít.

  4. Přidejte značku hemlock do této skupiny obrázků a stisknutím klávesy Enter značku použijte.

  5. Vyberte Nahrát soubory (10).

    Nahrajte soubory označené jako hemlock do Custom Vision

  6. Po úspěšném nahrání obrázků vyberte Hotovo.

  7. Znovu vyberte Přidat obrázky.

  8. Přejděte do druhé složky s obrázky Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Vyberte všech 10 obrázků ve složce a pak vyberte Otevřít.

  9. Přidejte k této skupině obrázků značku Japanese cherry a stiskněte enter, aby se značka použila.

  10. Vyberte Nahrát soubory (10). Po úspěšném nahrání obrázků vyberte Hotovo.

  11. Po označení a nahrání sad obrázků vyberte Train pro spuštění tréninku klasifikátoru.

Export klasifikátoru

  1. Po natrénování klasifikátoru na stránce Výkon klasifikátoru vyberte Exportovat.

    Export vytrénovaného klasifikátoru obrázků

  2. Jako platformu vyberte DockerFile.

  3. Jako verzi vyberte Linux.

  4. Vyberte Exportovat.

  5. Po dokončení exportu vyberte Stáhnout a uložit balíček .zip místně do počítače. Extrahujte z balíčku všechny soubory. Pomocí těchto souborů vytvořte modul IoT Edge, který obsahuje server klasifikace obrázků.

Až se k tomuto bodu dostanete, budete mít vytvořený a natrénovaný projekt služby Custom Vision. Exportované soubory použijete v další části, ale s webovou stránkou služby Custom Vision jste už skončili.

Vytvoření řešení IoT Edge

Teď máte soubory pro kontejnerovou verzi klasifikátoru obrázků ve vašem vývojovém počítači. V této části nastavíte kontejner klasifikátoru obrázků tak, aby běžel jako modul IoT Edge. Vytvoříte také druhý modul, který publikuje požadavky na klasifikátor a odešle výsledky jako zprávy IoT Hub.

Vytvoření nového řešení

Řešení je logický způsob vývoje a uspořádání více modulů pro jedno nasazení IoT Edge. Řešení obsahuje kód pro jeden nebo více modulů a manifest nasazení, který deklaruje, jak je nakonfigurovat na IoT Edge zařízení. Vytvořte řešení pomocí vývojového nástroje příkazového řádku (CLI) Azure IoT Edge Dev Tool. Nejjednodušší způsob, jak tento nástroj použít, je Spuštění IoT Edge vývojového kontejneru pomocí Dockeru.

  1. Vytvořte adresář s názvem classifier a přejděte do adresáře.

    mkdir CustomVisionSolution
cd CustomVisionSolution

  2. Spuštěním příkazu init nástroje iotedgedev vytvořte nové řešení IoT Edge. V kontejneru IoT Edge Dev Dockeru zadejte následující příkaz:

    iotedgedev solution init --template python --module classifier

    Inicializační skript řešení iotedgedev vás vyzve k provedení několika kroků, mezi které patří:

    • Ověření v Azure
    • Volba předplatného Azure
    • Vyberte nebo vytvořte skupinu prostředků
    • Vyberte nebo vytvořte Azure IoT Hub
    • Volba nebo vytvoření Azure IoT Edge zařízení

    Příkaz vytvoří nové řešení IoT Edge s modulem s názvem classifier v aktuálním pracovním adresáři.

  3. Otevřete řešení v Visual Studio Code.

Přidání klasifikátoru obrázků

Šablona modulu Python v Visual Studio Code obsahuje ukázkový kód, který můžete spustit pro testování IoT Edge. V tomto scénáři tento kód nevyužijete. Místo toho pomocí postupu v této části nahraďte vzorový kód kontejnerem klasifikátoru obrázků, který jste exportovali dříve.

  1. V Průzkumníku souborů přejděte k balíčku služby Custom Vision, který jste stáhli a extrahovali. Zkopírujte veškerý obsah extrahovaného balíčku. Mělo by se jednat o dvě složky (app a azureml) a dva soubory (Dockerfile a README).

  2. V Průzkumníku souborů přejděte do adresáře, do kterého jste Visual Studio Code řekli, že chcete vytvořit řešení IoT Edge.

  3. Otevřete složku modulu classifier. Pokud jste v předchozí části použili navrhované názvy, vypadá struktura složek takto: CustomVisionSolution / modules / classifier.

  4. Vložte soubory do složky classifier.

  5. Vraťte se do okna Visual Studio Code. Ve vašem pracovním prostoru řešení by se teď ve složce modulu měly zobrazit soubory klasifikátoru obrázků.

  6. Nahraďte původní soubor Dockerfile.amd64 souborem Dockerfile z balíčku custom vision odstraněním původního souboru Dockerfile.amd64 a přejmenováním souboru Dockerfile na Dockerfile.amd64.

  7. Uložte provedené změny.

Vytvoření modulu simulované kamery

Při skutečném nasazení vlastního vizuálního systému kamera poskytuje živé obrázky nebo videostreamy. V tomto scénáři budete simulovat kameru tím, že vytvoříte modul, který do klasifikátoru obrázků odešle testovací obrázek.

V této části do stejného řešení CustomVisionSolution přidáte nový modul a zadáte kód pro vytvoření simulované kamery.

  1. Pomocí nástroje iotedgedev přidejte do řešení nový modul. Příkaz vytvoří novou složku s názvem cameracapture ve složce modulů vašeho řešení.

    iotedgedev solution add --template python cameracapture

  2. Otevřete soubor main.py ve složcecameracapture / .

  3. Celý soubor nahraďte následujícím kódem. Tento vzorový kód odesílá požadavky POST do služby pro zpracování obrázků spuštěné v modulu classifier. Pro tento kontejner modulu zadáme ukázkový obrázek, který se použije v požadavcích. Pak zabalí odpověď jako IoT Hub zprávu a odešle ji do výstupní fronty.

    # 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. Uložte soubor main.py .

  5. Otevřete soubor requirements.txt.

  6. Přidejte nový řádek pro knihovnu, která se zahrne do kontejneru.

    requests

  7. Uložte soubor requirements.txt.

Přidání testovacího obrázku do kontejneru

Místo toho, abychom k poskytování kanálu obrázků pro tento scénář použili skutečnou kameru, použijeme jeden testovací obrázek. Testovací obrázek je součástí úložiště GitHub, které jste si stáhli pro trénovací obrázky dříve v tomto kurzu.

  1. Přejděte na testovací obrázek. Cognitive-CustomVision-Windows / Samples / Images / Test.

  2. Zkopírujte soubor test_image.jpg.

  3. Přejděte do adresáře řešení IoT Edge a vložte testovací obrázek do složky modules / cameracapture. Obrázek musí být ve stejné složce jako soubor main.py, který jste upravovali v předchozí části.

  4. V Visual Studio Code otevřete soubor Dockerfile.amd64 modulu cameracapture.

  5. Za řádek, který určuje pracovní adresář (WORKDIR /app) přidejte následující řádek kódu:

    ADD ./test_image.jpg .

  6. Uložte soubor Dockerfile.

Příprava manifestu nasazení

Zatím jste v tomto kurzu natrénovali vlastní model zpracování obrazu, abyste klasifikovali obrázky stromů a tento model zabalili jako modul IoT Edge. Pak jste vytvořili druhý modul, který se dotazuje na server klasifikace obrázků a hlásí jeho výsledky IoT Hub. Nyní jste připraveni vytvořit manifest nasazení, který informuje zařízení IoT Edge, jak tyto dva moduly spustit a provozovat společně.

Rozšíření IoT Edge pro Visual Studio Code poskytuje šablonu v každém IoT Edge řešení, které vám pomůže vytvořit manifest nasazení.

  1. Otevřete soubor deployment.template.json ve složce řešení.

  2. Nastavte přihlašovací údaje registru pro moduly v manifestu nasazení.

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

    Nahraďte <registryName> názvem registru kontejneru Azure. a nahraďte <AcrUsername> a <AcrPassword> uživatelským jménem a heslem registru. Tyto hodnoty najdete v části klíče Access registru kontejneru Azure na portálu Azure.

  3. Vyhledejte oddíl moduly, který obsahuje tři moduly: dva, které jste vytvořili, klasifikátor a zachycení kamery, a třetí, který je ve výchozím nastavení součástí, tempSensor.

  4. Odstraňte modul tempSensor se všemi jeho parametry. Tento modul poskytuje ukázková data pro testovací scénáře, ale v tomto nasazení není potřeba.

  5. Pokud jste modul klasifikace obrázků pojmenovali jinak než classifier, zkontrolujte teď název a ujistěte se, že obsahuje pouze malá písmena. Modul cameracapture volá modul klasifikátoru pomocí knihovny Requests, která formátuje všechny požadavky malými písmeny, a IoT Edge rozlišuje malá a velká písmena.

  6. Pro každý systémový modul edgeAgent a edgeHub změňte hodnotu createOptions na řetězcovou verzi. Například:

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

  7. Pro každý systémový modul edgeAgent a EdgeHub změňte verzi image na nejnovější verzi 1.5. Například:

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

  8. Aktualizujte parametr createOptions pro modul klasifikátoru na řetězcovou verzi. Například:

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

  9. Aktualizujte parametr createOptions pro modul cameracapture následujícím kódem JSON. S použitím těchto informací se v kontejneru modulu vytvoří proměnné prostředí, které se načítají v procesu main.py. Zahrnutím těchto informací do manifestu nasazení můžete změnit image nebo koncový bod bez opětovného sestavení image modulu.

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

    Pokud jste modul služby Custom Vision pojmenovali jinak než classifier, aktualizujte odpovídajícím způsobem hodnotu koncového bodu pro zpracování obrázků.

    Například klasifikátor a konfigurace fotoaparátu by měly být podobné:

    "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. Uložte soubor deployment.template.json .

Sestavení a nasazení IoT Edge řešení

Po vytvoření obou modulů a konfiguraci šablony manifestu nasazení sestavte image kontejneru a nasdílejte je do registru kontejneru.

Jakmile jsou image ve vašem registru, můžete řešení nasadit do IoT Edge zařízení. Moduly na zařízení můžete nastavit prostřednictvím IoT Hub. V této části nastavíte přístup k IoT Hub pak pomocí Azure CLI nasadíte řešení do IoT Edge zařízení.

Nejprve sestavte a odešlete řešení do registru kontejneru.

  1. Otevřete integrovaný terminál Visual Studio Code tak, že vyberete View>Terminal.

  2. Přihlaste se k Dockeru zadáním následujícího příkazu v terminálu pomocí uživatelského jména, hesla a přihlašovacího serveru z registru kontejneru Azure. Tyto hodnoty můžete načíst z oddílu Access keys registru na portálu Azure.

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

    Může se zobrazit upozornění zabezpečení, které doporučuje použití --password-stdin. I když se tento osvědčený postup doporučuje pro produkční scénáře, je mimo rozsah tohoto kurzu. Další informace najdete v referenčních informacích k přihlášení dockeru .

  3. Pomocí souboru Dockerfile modulu sestavte a označte obraz modulu Docker.

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

    Pokud například chcete vytvořit image místního registru nebo registru kontejneru Azure, použijte následující příkazy:

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

Odeslat obrázek Dockeru modulu

Zadejte přihlašovací údaje registru kontejneru do Dockeru, aby mohla odeslat image kontejneru do úložiště v registru.

  1. Přihlaste se k Dockeru pomocí přihlašovacích údajů Azure Container Registry (ACR).

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

    Může se zobrazit upozornění zabezpečení, které doporučuje použití --password-stdin. I když se jedná o doporučený osvědčený postup pro produkční scénáře, je to mimo rozsah tohoto kurzu. Další informace najdete v referenčních informacích k přihlášení dockeru .

  2. Přihlaste se k Azure Container Registry. Pokud chcete použít příkaz , musíte az. Tento příkaz požádá o uživatelské jméno a heslo, které najdete v registru kontejneru vpřístupových klíčích>.

    az acr login -n <AcrRegistryName>

    Návod

    Pokud se v tomto kurzu v libovolném okamžiku odhlásíte, opakujte kroky pro přihlášení do Docker a Azure Container Registry, abyste mohli pokračovat.

  3. Vložte image modulu do místního registru nebo do registru kontejneru.

    docker push <ImageName>

    Například:

    # 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

Aktualizace šablony nasazení

Aktualizujte soubor deployment.template.json s umístěním obrazu registru kontejneru. Změňte hodnotu image na image , kterou jste odeslali do registru. Nahraďte <například AcrRegistryName> názvem vašeho registru v hodnotách image pro moduly classifier a cameracapture:

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

Konečný manifest nasazení vypadá podobně jako následující:

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

Nasazení modulů do zařízení

Ověřte, že jsou vytvořené image kontejneru uložené v registru kontejneru. Pak je nasaďte do zařízení pomocí manifestu nasazení deployment.template.json připravení pro váš scénář.

Pomocí příkazu IoT Edge Azure CLI set-modules nasaďte moduly do Azure IoT Hub. Pokud chcete například nasadit moduly definované v souboru deployment.template.json na IoT Hub <IotHubName> pro IoT Edge zařízení <DeviceName>, použijte následující příkaz. Nahraďte hodnoty pro hub-name, device-id a login IoT Hub connection string vlastním.

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

Návod

IoT Hub connection string, včetně sdíleného přístupového klíče, najdete na portálu Azure. Přejděte na nastavení IoT Hub >Security>Sdílené zásady přístupu>iothubowner.

Ujistěte se, že je vaše zařízení IoT Edge spuštěné.

V zařízení rozbalte moduly a zobrazte seznam nasazených a spuštěných modulů. Vyberte tlačítko aktualizovat. Zobrazí se nové klasifikátor a moduly cameracapture spuštěné společně s $edgeAgent a $edgeHub.

Můžete také zkontrolovat, jestli jsou na vašem zařízení zprovozněné všechny moduly. Na IoT Edge zařízení spusťte následující příkaz a zobrazte stav modulů.

iotedge list

Spuštění modulů může trvat několik minut. Runtime IoT Edge musí obdržet nový manifest nasazení, stáhnout image modulů z runtime kontejneru, a poté spustit každý nový modul.

Zobrazení výsledků klasifikace

Na zařízení si prohlédněte protokoly modulu cameracapture, abyste viděli odeslané zprávy a potvrdili, že jsou přijaty IoT Hub.

iotedge logs cameracapture

Například byste měli vidět výstup podobný tomuto:

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

Poznámka:

Zpočátku se ve výstupu modulu cameracapture můžou zobrazovat chyby připojení kvůli zpoždění mezi nasazenými a spouštěcími moduly.

Modul cameracapture se automaticky opakovaně pokouší o připojení, dokud nebude úspěšné. Po úspěšném připojení se zobrazí očekávané zprávy klasifikace obrázků.

Výsledky z modulu Custom Vision, odeslané jako zprávy z modulu cameracapture, zahrnují pravděpodobnost, že je na obrázku tis nebo třešeň. Vzhledem k tomu, že obrázek obsahuje rostlinu náprstník (hemlock), vidíte pravděpodobnost jako 1,0.

Vyčištění prostředků

Pokud máte v plánu pokračovat k dalšímu doporučenému článku, ponechte prostředky a konfigurace, které jste vytvořili, a znovu je použijte. Můžete také dál používat stejné IoT Edge zařízení jako testovací zařízení.

Jinak odstraňte místní konfigurace a prostředky Azure, které jste použili v tomto článku, abyste se vyhnuli poplatkům.

Odstraňte prostředky Azure

Odstranění prostředků a skupin prostředků v Azure nelze vrátit zpět. Dávejte pozor, abyste nechtěně neodstranili nesprávnou skupinu prostředků nebo jednotlivé prostředky. Pokud jste vytvořili IoT Hub uvnitř existující skupiny prostředků, která obsahuje prostředky, které chcete zachovat, odstraňte pouze samotný IoT Hub prostředek, nikoli skupinu prostředků.

Chcete-li odstranit prostředky:

  1. Přihlaste se k portálu Azure a vyberte Sourcové skupiny.
  2. Vyberte název skupiny prostředků, která obsahuje vaše IoT Edge testovací prostředky.
  3. Zkontrolujte seznam prostředků, které vaše skupina prostředků obsahuje. Pokud chcete odstranit všechny prostředky, můžete vybrat možnost Odstranit skupinu prostředků. Pokud chcete odstranit jenom některé z nich, vyberte jednotlivé prostředky, abyste je odstranili jednotlivě.

Další kroky

V tomto kurzu jste vytrénovali model Custom Vision a nasadili ho jako modul do IoT Edge zařízení. Pak jste vytvořili modul, který může dotazovat službu klasifikace obrázků a hlásit výsledky zpět do IoT Hub.

V dalších tutoriálech se naučíte o dalších způsobech, jak Azure IoT Edge může pomoci převést data na obchodní přehledy na okraji.

Vyvíjejte moduly Azure IoT Edge pomocí Visual Studio Code

  • Last updated on