Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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:

Creare un componente generato automaticamente

Genera il componente del modello con CreateEdgePackagingJobAPIe specifica GreengrassV2Component per il API campo SageMaker Edge Manager Packaging JobPresetDeploymentType. Quando chiami il CreateEdgePackagingJobAPI, Edge Manager prende il tuo modello SageMaker NEO compilato 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. CreateEdgePackagingJob API

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 = 'edge-manager-amzn-s3-demo-bucket'

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

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

Accedi al bucket Amazon S3 URI in cui desideri archiviare l'output del processo di imballaggio e la chiave di crittografia opzionale.

Completa quanto segue per creare il componente del modello:

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 g. RPC L'agente Edge Manager utilizza i metodi definiti in Protobuf Buffers e nel g RPC server per stabilire la comunicazione con l'applicazione client sul dispositivo perimetrale e sul cloud.

Per usare gRPC, devi:

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

Installa g RPC e altri strumenti necessari sulla tua macchina host e crea i g RPC stub 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 g RPC client e server a partire dalla definizione del servizio .proto. In altre parole, crea il RPC modello g in Python. La API directory contiene la specifica Protobuf per comunicare con l'agente.

Quindi, usa g RPC API per scrivere un client e un server per il tuo 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()

Assicurati che model_path indichi il nome del AWS IoT Greengrass componente che contiene il modello se utilizzi lo stesso esempio di codice client.

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

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