Tutorial: Classificar imagens na periferia com o Serviço de Visão Personalizada

Artigo
04/11/2024

Aplica-se a: IoT Edge 1.5 IoT Edge 1.4

Importante

IoT Edge 1.5 LTS e IoT Edge 1.4 LTS são versões suportadas. O IoT Edge 1.4 LTS termina a vida útil em 12 de novembro de 2024. Se tiver uma versão anterior, consulte Atualizar IoT Edge.

O Azure IoT Edge pode mover as suas cargas de trabalho da cloud para a periferia e tornar a sua solução IoT Edge mais eficiente. Essa capacidade se presta bem a serviços que processam grandes quantidades de dados, como modelos de visão computacional. A Visão Personalizada do Azure AI permite-lhe criar classificadores de imagem personalizados e implementá-los em dispositivos como contentores. Em conjunto, estes dois serviços permitem-lhe obter informações de imagens ou de transmissões em fluxo de vídeos sem que seja necessário transferir todos os dados do local primeiro. A Visão Personalizada oferece um classificador que compara uma imagem com um modelo preparado para gerar informações.

Por exemplo, a Visão Personalizada num dispositivo IoT Edge pode determinar se o tráfego numa autoestrada é superior ou inferior ao normal ou se um parque de estacionamento tem lugares disponíveis numa fila. Essas informações podem ser partilhadas com outro serviço, o que possibilita realizar ações.

Neste tutorial, irá aprender a:

Compilar um classificador de imagens com a Visão Personalizada.
Desenvolver um módulo do IoT Edge que consulta o servidor Web da Visão Personalizada no seu dispositivo.
Enviar os resultados do classificador de imagens para o Hub IoT.

Diagrama - Tutorial de arquitetura, classificador de estágio e implantação

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.

Pré-requisitos

Gorjeta

Este tutorial é uma versão simplificada da Visão Personalizada e do Azure IoT Edge em um projeto de exemplo do Raspberry Pi 3 . Este tutorial foi projetado para ser executado em uma VM na nuvem e usa imagens estáticas para treinar e testar o classificador de imagens, o que é útil para alguém que está começando a avaliar a Visão Personalizada no IoT Edge. O projeto de exemplo usa hardware físico e configura um feed de câmera ao vivo para treinar e testar o classificador de imagem, o que é útil para alguém que deseja experimentar um cenário mais detalhado da vida real.

Configure seu ambiente para desenvolvimento de contêineres Linux concluindo Tutorial: Desenvolver módulos do IoT Edge usando o Visual Studio Code. Depois de concluir o tutorial, você deve ter os seguintes pré-requisitos disponíveis em seu ambiente de desenvolvimento:
- Um Hub IoT no escalão gratuito ou standard no Azure.
- Um dispositivo que executa o Azure IoT Edge com contêineres Linux. Você pode usar os inícios rápidos para configurar um dispositivo Linux ou um dispositivo Windows.
- Um registro de contêiner, como o Azure Container Registry.
- Código do Visual Studio configurado com as extensões Azure IoT Edge e Azure IoT Hub . A extensão de código das ferramentas do Azure IoT Edge para Visual Studio está no modo de manutenção.
- Baixe e instale um sistema de gerenciamento de contêineres compatível com Docker em sua máquina de desenvolvimento. Configure-o para executar contêineres Linux.
Para desenvolver um módulo IoT Edge com o serviço Visão Personalizada, instale os seguintes pré-requisitos adicionais em sua máquina de desenvolvimento:
- Python
- Git
- Extensão Python para o Visual Studio Code

Compilar um classificador de imagens com a Visão Personalizada

Para compilar um classificador de imagens, tem de criar um projeto de Visão Personalizada e fornecer imagens de preparação. Para obter mais informações sobre os passos que vai seguir nesta secção, veja How to build a classifier with Custom Vision (Como compilar um classificador com a Visão Personalizada).

Quando o classificador de imagens estiver compilado e preparado, pode exportá-lo como um contentor do Docker e importá-lo num dispositivo IoT Edge.

Criar um novo projeto

No browser, navegue para a página Web Visão Personalizada.
Selecione Sign in (Iniciar sessão) e inicie sessão na mesma conta que utiliza para aceder aos recursos do Azure.
Selecione Novo projeto.

Crie o projeto com os valores seguintes:

Campo	Valor
Nome	Indique um nome para o projeto, como EdgeTreeClassifier.
Description	Descrição do projeto opcional.
Recurso	Selecione um dos seus grupos de recursos do Azure que inclua um recurso do Serviço de Visão Personalizada ou crie um novo se ainda não tiver adicionado um.
Tipos de Projetos	Classificação
Tipos de Classificações	Multiclass (single tag per image) (Multiclasses [etiqueta individual por imagem])
Domínios	General (compact) (Geral [compacto])
Capacidades de exportação	Plataformas básicas (Tensorflow, CoreML, ONNX, ...)

Selecione Criar projeto.

Carregar imagens e preparar o classificador

Criar um classificador de imagens requer um conjunto de imagens de treinamento e imagens de teste.

Clone ou transfira as imagens de exemplo do repositório Cognitive-CustomVision-Windows para o seu computador de desenvolvimento local.
```
git clone https://github.com/Microsoft/Cognitive-CustomVision-Windows.git
```
Regresse ao projeto de Visão Personalizada e selecione Add images (Adicionar imagens).
Navegue para o repositório do git que clonou localmente e aceda à primeira pasta de imagens, Cognitive-CustomVision-Windows / Samples / Images / Hemlock. Selecione as 10 imagens na pasta e selecione Open (Abrir).
Adicione a etiqueta hemlock a este grupo de imagens e prima enter para a aplicar.
Selecione Upload 10 files (Até 10 ficheiros).
Quando as imagens estiverem carregadas, selecione Done (Concluído).
Selecione novamente Add images (Adicionar imagens).
Navegue para a segunda pasta de imagens, Cognitive-CustomVision-Windows / Samples / Images / Japanese Cherry. Selecione as 10 imagens na pasta e selecione Open (Abrir).
Adicione a etiqueta japanese cherry a este grupo de imagens e prima enter para a aplicar.
Selecione Upload 10 files (Até 10 ficheiros). Quando as imagens estiverem carregadas, selecione Done (Concluído).
Quando ambos os conjunto de imagens estiverem etiquetados e carregados, selecione Train (Preparar) para preparar o classificador.

Exportar o classificador

Depois de preparar o classificador, selecione Export (Exportar), na página Performance (Desempenho) do mesmo.
Selecione DockerFile para a plataforma.
Selecione Linux para a versão.
Selecione Exportar.
Após a conclusão da exportação, selecione Download (Transferir) e guarde o pacote .zip localmente no computador. Extraia todos os ficheiros do pacote. Use esses arquivos para criar um módulo do IoT Edge que contenha o servidor de classificação de imagem.

Quando chegar a esta fase, terá concluído a criação e a preparação do projeto de Visão Personalizada. Vai precisar dos ficheiros exportados na próxima secção, mas já não vai utilizar a página Web da Visão Personalizada.

Criar uma solução do IoT Edge

Agora, tem os ficheiros para uma versão de contentor do classificador de imagens no seu computador de desenvolvimento. Nesta secção, vai configurar o contentor do classificador de imagens para ser executado como um módulo do IoT Edge. Você também cria um segundo módulo que é implantado junto com o classificador de imagem. Este segundo módulo publica pedidos no classificador e envia os resultados como mensagens para o Hub IoT.

Criar uma nova solução

Uma solução é uma forma lógica de desenvolver e organizar vários módulos para uma implementação do IoT Edge individual. Uma solução contém código para um ou mais módulos e o manifesto de implantação que declara como configurá-los em um dispositivo IoT Edge.

No Visual Studio Code, selecione View>Command Palette para abrir a paleta de comandos Visual Studio Code.

Na paleta de comandos, introduza e execute o comando Azure IoT Edge: Nova solução do IoT Edge. Na paleta de comandos, indique as seguintes informações para criar a sua solução:

Campo	Value
Selecionar pasta	Escolha o local em sua máquina de desenvolvimento para Visual Studio Code para criar os arquivos de solução.
Indicar um nome para a solução	Introduza um nome descritivo para a solução, como CustomVisionSolution, ou aceite o predefinido.
Selecionar modelo de módulo	Escolha Python Module (Módulo de Python).
Indicar um nome para o módulo	Dê o nome classifier ao módulo. É importante que o nome deste módulo seja minúsculo. Quando referencia módulos, o IoT Edge é sensível a maiúsculas e minúsculas e esta solução utiliza uma biblioteca que formata todos os pedidos em minúsculas.
Indicar o repositório de imagens do Docker para o módulo	Os repositórios de imagens incluem o nome do seu registo de contentor e o nome da sua imagem de contentor. A imagem de contentor é pré-preenchida no passo anterior. Substitua localhost:5000 pelo valor do servidor de Logon do seu registro de contêiner do Azure. Você pode recuperar o servidor de Logon na página Visão geral do seu registro de contêiner no portal do Azure. A cadeia de caracteres final se parece com <o nome> do registro.azurecr.io/classifier.

Fornecer repositório de imagens do Docker

A janela do Visual Studio Code carrega a sua área de trabalho da solução do IoT Edge.

Adicionar as credenciais do registo

O ficheiro de ambiente armazena as credenciais do seu registo de contentor e partilha-as com o runtime do IoT Edge. O runtime precisa destas credenciais para solicitar as imagens privadas para o dispositivo IoT Edge.

A extensão IoT Edge tenta extrair suas credenciais de registro de contêiner do Azure e as preenche no arquivo de ambiente. Verifique se as suas credenciais já estão incluídas. Se não, adicione-os agora:

No explorador de código do Visual Studio, abra o arquivo .env.
Atualize os campos com os valores nome de utilizador e palavra-passe que copiou do seu Azure Container Registry.
Guarde este ficheiro.

Nota

Este tutorial usa credenciais de logon de administrador para o Registro de Contêiner do Azure, que são convenientes para cenários de desenvolvimento e teste. Quando estiver pronto para cenários de produção, recomendamos uma opção de autenticação de privilégios mínimos, como entidades de serviço. Para obter mais informações, consulte Gerenciar o acesso ao registro de contêiner.

Selecione sua arquitetura de destino

Atualmente, o Visual Studio Code pode desenvolver módulos para dispositivos Linux AMD64 e Linux ARM32v7. Você precisa selecionar qual arquitetura você está segmentando com cada solução, porque o contêiner é criado e executado de forma diferente para cada tipo de arquitetura. O padrão é Linux AMD64, que é o que usamos para este tutorial.

Abra a paleta de comandos e procure Azure IoT Edge: set Default Target Platform for Edge Solution ou selecione o ícone de atalho na barra lateral na parte inferior da janela.
Na paleta de comandos, selecione a arquitetura de destino na lista de opções. Para este tutorial, estamos usando uma máquina virtual Ubuntu como o dispositivo IoT Edge, portanto, mantenha o amd64 padrão.

Adicionar o classificador de imagens

O modelo de módulo Python no Visual Studio Code contém algum código de exemplo que você pode executar para testar o IoT Edge. Esse código não vai ser utilizado neste cenário. Em vez disso, utilize os passos nesta secção para substituir o código de exemplo pelo contentor do classificador de imagens que exportou anteriormente.

No explorador de ficheiros, navegue para o pacote da Visão Personalizada que transferiu e extraiu. Copie todos os conteúdos do pacote extraído. Deverá haver duas pastas, app e azureml, e dois ficheiros, Dockerfile e README.
No explorador de ficheiros, navegue para o diretório que instruiu o Visual Studio Code para criar a solução do IoT Edge.
Abra a pasta do módulo do classificador. Se tiver utilizado os nomes sugeridos na secção anterior, a estrutura da pasta será semelhante a CustomVisionSolution / modules / classifier.
Cole os ficheiros na pasta classifier.
Regresse à janela do Visual Studio Code. A área de trabalho da solução deverá agora mostrar os ficheiros do classificador de imagens na pasta do módulo.
Abra o ficheiro module.json na pasta do classificador.
Atualize o parâmetro platforms para apontar para o novo Dockerfile que você adicionou e remova todas as opções além do AMD64, que é a única arquitetura que estamos usando para este tutorial.
```
"platforms": {
    "amd64": "./Dockerfile"
}
```
Guardar as suas alterações.

Criar um módulo de câmara simulada

Numa implementação da Visão Personalizada real, as imagens ou as transmissões em fluxo de vídeo em direto seriam fornecidas por uma câmera. Neste cenário, a câmara vai ser simulada mediante a compilação de um módulo que envia uma imagem de teste para o classificador de imagens.

Adicionar e configurar um módulo novo

Nesta secção, vai adicionar um módulo novo à mesma CustomVisionSolution e fornecer código para criar a câmara simulada.

Na mesma janela do Visual Studio Code, utilize a paleta de comandos para executar Azure IoT Edge: Add IoT Edge Module. Na paleta de comandos, indique as informações seguintes relativas ao módulo novo:

Pedido	Value
Selecione o ficheiro de modelo da implementação	Selecione o arquivo deployment.template.json na pasta CustomVisionSolution.
Selecionar modelo de módulo	Selecione Python Module (Módulo de Python).
Indicar um nome para o módulo	Dê ao módulo o nome cameraCapture
Indicar o repositório de imagens do Docker para o módulo	Substitua localhost:5000 pelo valor do servidor de Logon para seu registro de contêiner do Azure. A cadeia final é semelhante a <registryname>.azurecr.io/cameracapture.

A janela Visual Studio Code carrega seu novo módulo no espaço de trabalho da solução e atualiza o arquivo deployment.template.json. Deverá ver agora duas pastas do módulo, classifier e cameraCapture.

Abra o ficheiro main.py na pasta modules / cameraCapture.

Substitua todo o ficheiro pelo código abaixo: Este código de exemplo envia pedidos POST para o serviço de processamento de imagens que está a ser executado no módulo do classificador. Este contentor de módulo é fornecido com uma imagem de exemplo que vai ser utilizada nos pedidos. Depois, empacota a resposta como uma mensagem do Hub IoT e envia-a para uma fila de saída.

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

Guarde o ficheiro main.py.
Abra o arquivo requirements.txt .
Adicione uma linha nova para uma biblioteca, para inclusão no contentor.
```
requests
```
Guarde o ficheiro requirements.txt.

Adicionar uma imagem de teste ao contentor

Neste cenário, em vez de utilizarmos uma câmara real para fornecer um feed de imagens, vamos utilizar uma imagem de teste individual. Está incluída uma imagem de teste no repositório do GitHub que transferiu para as imagens de preparação no início do tutorial.

Navegue para a imagem de teste, localizada em Cognitive-CustomVision-Windows / Samples / Images / Test.
Copie test_image.jpg
Navegue para o diretório da solução do IoT Edge e cole a imagem de teste na pasta modules / cameraCapture. A imagem deverá estar na mesma pasta que o ficheiro main.py que foi editado na última secção.
No Visual Studio Code, abra o ficheiro Dockerfile.amd64 relativo ao módulo cameraCapture.
Adicione a linha de código abaixo a seguir à linha que estabelece o diretório de trabalho, WORKDIR /app:
```
ADD ./test_image.jpg .
```
Guarde o Dockerfile.

Preparar um manifesto de implementação

Até esta fase do tutorial, preparou um modelo da Visão Personalizada para classificar imagens de árvores e empacotou-o como um módulo do IoT Edge. Depois, criou um segundo módulo que pode consultar o servidor de classificação de imagens e comunicar os resultados ao Hub IoT. Agora, está pronto para criar o manifesto de implementação que vai dizer a um dispositivo IoT Edge como deve iniciar e executar esses dois módulos em conjunto.

A extensão IoT Edge para o Visual Studio Code disponibiliza um modelo em cada solução do IoT Edge que o ajuda a criar um manifesto de implementação.

Abra o ficheiro deployment.template.json na pasta da solução.
Encontre a seção de módulos , que deve conter três módulos: os dois que você criou, classificador e cameraCapture, e um terceiro incluído por padrão, SimulatedTemperatureSensor.
Exclua o módulo SimulatedTemperatureSensor com todos os seus parâmetros. Este módulo é incluído para fornecer os dados de exemplo para cenários de teste, mas não precisamos do mesmo nesta implementação.
Se tiver dado ao módulo de classificação de imagens outro nome que não classifier, verifique o nome e confirme que está em minúsculas. O módulo cameraCapture chama o módulo classifier com uma biblioteca de pedidos que formata todos os pedidos em minúsculas e o IoT Edge é sensível a maiúsculas e minúsculas.
Atualize o parâmetro createOptions para o módulo cameraCapture com o JSON seguinte. Esta informação cria variáveis de ambiente no contentor do módulo que são obtidas no processo main.py. A inclusão dessa informação no manifesto da implementação permite-lhe alterar a imagem ou o ponto final sem ter de recompilar a imagem do módulo.
```
"createOptions": "{\"Env\":[\"IMAGE_PATH=test_image.jpg\",\"IMAGE_PROCESSING_ENDPOINT=http://classifier/image\"]}"
```
Se tiver dado ao módulo da Visão Personalizada outro nome que não classifier, atualize o valor do ponto final do processamento de imagens para corresponder ao mesmo.
Na parte inferior do ficheiro, atualize o parâmetro routes para o módulo $edgeHub. Os resultados da predição devem ser encaminhados de cameraCapture para o Hub IoT.
```
    "routes": {
      "cameraCaptureToIoTHub": "FROM /messages/modules/cameraCapture/outputs/* INTO $upstream"
    },
```
Se tiver dado ao segundo módulo outro nome que não cameraCapture, atualize o valor da rota para corresponder ao mesmo.
Guarde o ficheiro deployment.template.json.

Crie e envie sua solução IoT Edge

Tendo ambos os módulos criados e o modelo do manifesto da implementação configurado, está pronto para compilar as imagens do contentor e enviá-las para o seu registo.

Quando as imagens estiverem no registo, pode implementar a solução num dispositivo IoT Edge. Pode definir módulos num dispositivo através do Hub IoT, mas também pode aceder o seu Hub IoT e dispositivos através do Visual Studio Code. Nesta seção, você configura o acesso ao seu Hub IoT e, em seguida, usa o Visual Studio Code para implantar sua solução em seu dispositivo IoT Edge.

Primeiro, compile e envie a solução para o registo de contentor.

Abra o terminal integrado do Visual Studio Code selecionando View>Terminal.
Faça login no Docker inserindo o seguinte comando no terminal. Entre com o nome de usuário, a senha e o servidor de logon do seu registro de contêiner do Azure. Você pode recuperar esses valores na seção Chaves de acesso do seu registro no portal do Azure.
```
docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Poderá receber um aviso de segurança a recomendar a utilização do --password-stdin. Embora essa prática recomendada seja recomendada para cenários de produção, ela está fora do escopo deste tutorial. Para obter mais informações, consulte a referência de login do docker.
No explorador de código do Visual Studio, clique com o botão direito do mouse no arquivo de deployment.template.json e selecione Criar e enviar por push a solução IoT Edge.

O comando build e push inicia três operações. Primeiro, ele cria uma nova pasta na solução chamada config que contém o manifesto de implantação completo, que é criado a partir de informações no modelo de implantação e outros arquivos de solução. Em segundo lugar, ele é executado docker build para criar a imagem do contêiner com base no dockerfile apropriado para sua arquitetura de destino. Em seguida, ele é executado docker push para enviar o repositório de imagens para o registro do contêiner.

Esse processo pode levar vários minutos na primeira vez, mas é mais rápido na próxima vez que você executar os comandos.

Implantar módulos no dispositivo

Use o explorador de código do Visual Studio e a extensão do Azure IoT Edge para implantar o projeto de módulo em seu dispositivo IoT Edge. Você já tem um manifesto de implantação preparado para seu cenário, o arquivo deployment.amd64.json na pasta config. Agora tudo o que precisa de fazer é selecionar um dispositivo para receber a implementação.

Certifique-se de que seu dispositivo IoT Edge esteja instalado e funcionando.

No explorador de código do Visual Studio, na seção Hub IoT do Azure, expanda Dispositivos para ver sua lista de dispositivos IoT.
Carregue com o botão direito do rato no nome do seu dispositivo do IoT Edge e, em seguida, selecione Criar Implementação para o Dispositivo Único.
Selecione o arquivo deployment.amd64.json na pasta config e, em seguida, selecione Manifesto de Implantação de Borda. Não use o arquivo deployment.template.json.
No dispositivo, expanda Módulos para ver uma lista de módulos implantados e em execução. Selecione o botão Atualizar. Você deve ver os novos módulos classificador e cameraCapture em execução junto com o $edgeAgent e $edgeHub.

Também pode verificar se todos os módulos estão em execução no seu dispositivo. No dispositivo IoT Edge, execute o seguinte comando para ver o estado dos módulos.

iotedge list

Pode levar alguns minutos para que os módulos iniciem. O tempo de execução do IoT Edge precisa receber seu novo manifesto de implantação, extrair as imagens do módulo do tempo de execução do contêiner e iniciar cada novo módulo.

Ver os resultados da classificação

Existem duas formas de ver os resultados dos seus módulos. Ou no próprio dispositivo, à medida que as mensagens são geradas e enviadas, ou do Visual Studio Code, à medida que as mensagens chegam ao Hub IoT.

No dispositivo, veja os registos do módulo cameraCapture para visualizar as mensagens que estão a ser enviadas e a confirmação de que o Hub IoT as recebeu.

iotedge logs cameraCapture

Por exemplo, você deve ver a saída como a seguinte:

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

Você também pode exibir mensagens do Visual Studio Code. Clique com o botão direito do mouse no nome do seu dispositivo IoT Edge e selecione Iniciar monitoramento de ponto de extremidade de evento interno.

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

Nota

Inicialmente, você pode ver erros de conexão na saída do módulo cameraCapture. Isso se deve ao atraso entre a implantação e o início dos módulos.

O módulo cameraCapture tenta automaticamente a conexão até que seja bem-sucedida. Após a conexão bem-sucedida, você verá as mensagens de classificação de imagem esperadas.

Os resultados do módulo Visão Personalizada que são enviados como mensagens do módulo cameraCapture, incluem a probabilidade de que a imagem seja de uma cicuta ou cerejeira. Uma vez que a imagem é de uma cicuta, a probabilidade deverá aparecer como 1,0.

Clean up resources (Limpar recursos)

Se planeia avançar para o próximo artigo recomendado, pode manter os recursos e as configurações que criou e reutilizá-los. Também pode continuar a utilizar o mesmo dispositivo IoT Edge como um dispositivo de teste.

Caso contrário, você pode excluir as configurações locais e os recursos do Azure usados neste artigo para evitar cobranças.

Eliminar recursos do Azure

A eliminação de recursos e grupos de recursos do Azure é irreversível. Confirme que não elimina acidentalmente o grupo de recursos ou recursos errados. Se você criou o hub IoT dentro de um grupo de recursos existente que tem recursos que deseja manter, exclua apenas o recurso do hub IoT em si, não o grupo de recursos.

Para eliminar os recursos:

Inicie sessão no Portal do Azure e selecione Grupos de recursos.
Selecione o nome do grupo de recursos que contém os recursos de teste do IoT Edge.
Reveja a lista de recursos contidos no seu grupo de recursos. Se quiser eliminá-los todos, pode selecionar Eliminar grupo de recursos. Se quiser eliminar apenas alguns dos recursos, pode clicar em cada um para eliminá-los individualmente.

Próximos passos

Neste tutorial, preparou um modelo de Visão Personalizada e implementou-o como um módulo num dispositivo IoT Edge. Depois, compilou um módulo que pode consultar o servidor de classificação de imagens e comunicar os resultados ao Hub IoT.

Continue para os próximos tutoriais para saber mais sobre outras maneiras pelas quais o Azure IoT Edge pode ajudá-lo a transformar dados em insights de negócios na borda.

Armazenar dados na periferia com bases de dados do SQL Server

Partilhar via