Crea i componenti V2 AWS IoT Greengrass

AWS IoT Greengrass utilizza components, un modulo software che viene distribuito e eseguito su un dispositivo AWS IoT Greengrass principale. Sono necessari (almeno) tre componenti:

1. Un AWS IoT Greengrass componente pubblico di Edge Manager Agent che distribuisce l'agente binario di Edge Manager.

2. Un componente del modello che viene generato automaticamente quando si impacchetta il modello di machine learning con l' AWS SDK for Python (Boto3) API o con la console AI. SageMaker Per informazioni, consultare Creare un componente generato automaticamente.

3. Un componente privato e personalizzato per implementare l'applicazione client dell'agente Edge Manager ed eseguire qualsiasi preelaborazione e post-elaborazione dei risultati dell'inferenza. Per ulteriori informazioni su come creare un componente personalizzato, consulta Creare un componente generato automaticamente la sezione Creare componenti personalizzati. AWS IoT Greengrass

Creare un componente generato automaticamente

Genera il componente del modello con l'CreateEdgePackagingJobAPI e specifica GreengrassV2Component il campo API del processo di imballaggio di SageMaker Edge ManagerPresetDeploymentType. Quando chiami l'CreateEdgePackagingJobAPI, Edge Manager prende il tuo modello compilato con SageMaker AI NEO in Amazon S3 e crea un componente del modello. Il componente del modello viene automaticamente archiviato nel tuo account. Puoi visualizzare qualsiasi componente accedendo alla console. AWS IoT https://console.aws.amazon.com/iot/ Seleziona Greengrass, quindi seleziona Dispositivi core. La pagina contiene un elenco dei dispositivi AWS IoT Greengrass principali associati al tuo account. Se il nome di un componente del modello non è specificato in PresetDeploymentConfig, il nome predefinito generato è costituito da "SagemakerEdgeManager" e dal nome del processo di creazione pacchetti dell'agente Edge Manager. L'esempio seguente mostra come specificare a Edge Manager di creare un componente AWS IoT Greengrass V2 con l'CreateEdgePackagingJobAPI.

import sagemaker
import boto3

# Create a SageMaker client object to make it easier to interact with other AWS services.
sagemaker_client = boto3.client('sagemaker', region=<YOUR_REGION>)

# Replace with your IAM Role ARN
sagemaker_role_arn = "arn:aws:iam::<account>:role/*"

# Replace string with the name of your already created S3 bucket.
bucket = 'amzn-s3-demo-bucket-edge-manager'

# Specify a name for your edge packaging job.
edge_packaging_name = "edge_packag_job_demo" 

# Replace the following string with the name you used for the SageMaker Neo compilation job.
compilation_job_name = "getting-started-demo" 

# The name of the model and the model version.
model_name = "sample-model" 
model_version = "1.1"

# Output directory in S3 where you want to store the packaged model.
packaging_output_dir = 'packaged_models' 
packaging_s3_output = 's3://{}/{}'.format(bucket, packaging_output_dir)

# The name you want your Greengrass component to have.
component_name = "SagemakerEdgeManager" + edge_packaging_name

sagemaker_client.create_edge_packaging_job(
                    EdgePackagingJobName=edge_packaging_name,
                    CompilationJobName=compilation_job_name,
                    RoleArn=sagemaker_role_arn,
                    ModelName=model_name,
                    ModelVersion=model_version,
                    OutputConfig={
                        "S3OutputLocation": packaging_s3_output,
                        "PresetDeploymentType":"GreengrassV2Component",
                        "PresetDeploymentConfig":"{\"ComponentName\":\"sample-component-name\", \"ComponentVersion\":\"1.0.2\"}"
                        }
                    )

Puoi anche creare il componente generato automaticamente con la console AI. SageMaker Segui le fasi da 1 a 6 descritte in Package a modello (Amazon SageMaker AI Console).

Inserisci l'URI del bucket Amazon S3 in cui desideri memorizzare l'output del processo di creazione pacchetti e la chiave di crittografia opzionale.

Completa quanto segue per creare il componente del modello:

1. Scegli Implementazione preimpostata.

2. Specifica il nome del componente nel campo Nome del componente.

3. Facoltativamente, fornisci una descrizione del componente, della versione del componente, del sistema operativo della piattaforma o dell'architettura della piattaforma rispettivamente per la Descrizione del componente, la Versione del componente, il Sistema operativo della piattaforma e l'Architettura della piattaforma.

4. Scegli Invia.

Crea un componente personalizzato Hello World

Il componente dell'applicazione personalizzato viene utilizzato per eseguire inferenze sul dispositivo edge. Il componente è responsabile del caricamento dei modelli su SageMaker Edge Manager, della chiamata all'agente Edge Manager per l'inferenza e dello scaricamento del modello quando il componente viene spento. Prima di creare il componente, assicurati che l'agente e l'applicazione possano comunicare con Edge Manager. Per fare ciò, configura gRPC. L'agente Edge Manager utilizza i metodi definiti in Protobuf Buffers e nel server gRPC per stabilire la comunicazione con l'applicazione client sul dispositivo edge e sul cloud.

Per usare gRPC, devi:

1. Creare uno stub gRPC utilizzando il file.proto fornito quando scarichi l'agente Edge Manager dal bucket di rilascio di Amazon S3.

2. Scrivere il codice client con la lingua che preferisci.

Non è necessario definire il servizio in un file .proto. I file di servizio .proto sono inclusi nel file TAR compresso quando scarichi il file binario della versione dell'agente Edge Manager dal bucket di rilascio di Amazon S3.

Installa gRPC e altri strumenti necessari sulla tua macchina host e crea gli stub gRPC agent_pb2_grpc.py e agent_pb2.py in Python. Assicurati di avere agent.proto nella tua directory locale.

%%bash
pip install grpcio
pip install grpcio-tools
python3 -m grpc_tools.protoc --proto_path=. --python_out=. --grpc_python_out=. agent.proto

Il codice precedente genera le interfacce client e server gRPC dalla definizione del servizio .proto. In altre parole, crea il modello gRPC in Python. La directory API contiene la specifica Protobuf per comunicare con l'agente.

Successivamente, usa l'API gRPC per scrivere un client e un server per il servizio (2). Lo script di esempio seguente edge_manager_python_example.py utilizza Python per caricare, elencare e scaricare un modello yolov3 sul dispositivo edge.

import grpc
from PIL import Image
import agent_pb2
import agent_pb2_grpc
import os


model_path = '<PATH-TO-SagemakerEdgeManager-COMPONENT>' 
                    
agent_socket = 'unix:///tmp/aws.greengrass.SageMakerEdgeManager.sock'

agent_channel = grpc.insecure_channel(agent_socket, options=(('grpc.enable_http_proxy', 0),))

agent_client = agent_pb2_grpc.AgentStub(agent_channel)


def list_models():
    return agent_client.ListModels(agent_pb2.ListModelsRequest())


def list_model_tensors(models):
    return {
        model.name: {
            'inputs': model.input_tensor_metadatas,
            'outputs': model.output_tensor_metadatas
        }
        for model in list_models().models
    }


def load_model(model_name, model_path):
    load_request = agent_pb2.LoadModelRequest()
    load_request.url = model_path
    load_request.name = model_name
    return agent_client.LoadModel(load_request)


def unload_model(name):
    unload_request = agent_pb2.UnLoadModelRequest()
    unload_request.name = name
    return agent_client.UnLoadModel(unload_request)


def predict_image(model_name, image_path):
    image_tensor = agent_pb2.Tensor()
    image_tensor.byte_data = Image.open(image_path).tobytes()
    image_tensor_metadata = list_model_tensors(list_models())[model_name]['inputs'][0]
    image_tensor.tensor_metadata.name = image_tensor_metadata.name
    image_tensor.tensor_metadata.data_type = image_tensor_metadata.data_type
    for shape in image_tensor_metadata.shape:
        image_tensor.tensor_metadata.shape.append(shape)
    predict_request = agent_pb2.PredictRequest()
    predict_request.name = model_name
    predict_request.tensors.append(image_tensor)
    predict_response = agent_client.Predict(predict_request)
    return predict_response

def main():
    try:
        unload_model('your-model')
    except:
        pass
  
    print('LoadModel...', end='')
    try:
        load_model('your-model', model_path)
        print('done.')
    except Exception as e:
        print()
        print(e)
        print('Model already loaded!')
        
    print('ListModels...', end='')
    try:
        print(list_models())
        print('done.')
        
    except Exception as e:
        print()
        print(e)
        print('List model failed!')
       
    print('Unload model...', end='')
    try:
        unload_model('your-model')
        print('done.')
    except Exception as e:
        print()
        print(e)
        print('unload model failed!')

if __name__ == '__main__':
    main()

Assicuratevi che model_path indichi il nome del AWS IoT Greengrass componente contenente il modello se utilizzate lo stesso esempio di codice client.

Puoi creare il tuo componente Hello World AWS IoT Greengrass V2 dopo aver generato i tuoi stub gRPC e aver pronto il codice Hello World. A tale scopo:

• Carica il tuo edge_manager_python_example.py, agent_pb2_grpc.py e agent_pb2.py nel tuo bucket Amazon S3 e annota il loro percorso Amazon S3.

• Crea un componente privato nella console AWS IoT Greengrass V2 e definisci la ricetta per il tuo componente. Specifica l'URI di Amazon S3 per l'applicazione Hello World e lo stub gRPC nella seguente ricetta.

  ---
  RecipeFormatVersion: 2020-01-25
  ComponentName: com.sagemaker.edgePythonExample
  ComponentVersion: 1.0.0
  ComponentDescription: Sagemaker Edge Manager Python example
  ComponentPublisher: Amazon Web Services, Inc.
  ComponentDependencies:
    aws.greengrass.SageMakerEdgeManager:
      VersionRequirement: '>=1.0.0'
      DependencyType: HARD
  Manifests:
    - Platform:
        os: linux
        architecture: "/amd64|x86/"
      Lifecycle:
        install: |-
          apt-get install python3-pip
          pip3 install grpcio
          pip3 install grpcio-tools
          pip3 install protobuf
          pip3 install Pillow
        run:
          script: |- 
            python3 {artifacts:path}/edge_manager_python_example.py
      Artifacts:
        - URI: <code-s3-path>
        - URI: <pb2-s3-path>
        - URI: <pb2-grpc-s3-path>

Per informazioni dettagliate sulla creazione di una ricetta Hello World, vedi Creare il tuo primo componente nella AWS IoT Greengrass documentazione.