Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Cree los componentes de la V2 AWS IoT Greengrass

AWS IoT Greengrass utiliza componentes, un módulo de software que se implementa en un dispositivo AWS IoT Greengrass central y se ejecuta en él. Necesita (como mínimo) tres componentes:

Crear un componente generado automáticamente

Genere el componente del modelo con el API campo de trabajo GreengrassV2Component de embalaje de SageMaker Edge Manager CreateEdgePackagingJobAPIy especifíqueloPresetDeploymentType. Cuando lo llama CreateEdgePackagingJobAPI, Edge Manager toma su modelo SageMaker compilado en NEO en Amazon S3 y crea un componente de modelo. El componente del modelo se almacena automáticamente en su cuenta. Puede ver cualquiera de sus componentes navegando a la consola. AWS IoT https://console.aws.amazon.com/iot/ Seleccione Greengrass y, a continuación, seleccione Dispositivos principales. La página contiene una lista de los dispositivos AWS IoT Greengrass principales asociados a tu cuenta. Si no se especifica el nombre de un componente del modelo en PresetDeploymentConfig, el nombre predeterminado generado será "SagemakerEdgeManager" y el nombre del trabajo de empaquetado del agente de Edge Manager. El siguiente ejemplo muestra cómo especificar a Edge Manager la creación de un componente AWS IoT Greengrass V2 con 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 = '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\"}"
                        }
                    )

También puede crear el componente generado automáticamente con la SageMaker consola. Siga los pasos del 1 al 6 en Package a model (Amazon SageMaker Console)

Introduzca el depósito de Amazon S3 URI en el que desee almacenar el resultado del trabajo de empaquetado y la clave de cifrado opcional.

Complete lo siguiente para crear el componente del modelo:

Crear un componente personalizado de Hello World

El componente de aplicación personalizado se utiliza para realizar inferencias en el dispositivo periférico. El componente se encarga de cargar los modelos en SageMaker Edge Manager, de invocar al agente de Edge Manager para realizar inferencias y de descargar el modelo cuando el componente está apagado. Antes de crear el componente, asegúrese de que el agente y la aplicación puedan comunicarse con Edge Manager. Para ello, configure g. RPC El agente Edge Manager utiliza los métodos definidos en Protobuf Buffers y el RPC servidor g para establecer la comunicación con la aplicación cliente en el dispositivo perimetral y en la nube.

Para usar gRPC, debes:

No es necesario definir el servicio en un archivo .proto. Los archivos.proto del servicio se incluyen en el TAR archivo comprimido al descargar el binario de la versión del agente Edge Manager del depósito de versiones de Amazon S3.

Instale g RPC y otras herramientas necesarias en su máquina host y cree los códigos RPC g agent_pb2_grpc.py y agent_pb2.py en Python. Asegúrese de tener agent.proto en su directorio local.

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

El código anterior genera las interfaces de RPC cliente y servidor g a partir de su definición de servicio.proto. En otras palabras, crea el RPC modelo g en Python. El API directorio contiene la especificación Protobuf para comunicarse con el agente.

A continuación, utilice la g RPC API para escribir un cliente y un servidor para su servicio (2). El siguiente script de ejemplo, edge_manager_python_example.py, usa Python para cargar, enumerar y descargar un modelo yolov3 en el dispositivo periférico.

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()

Asegúrese de que model_path apunta al nombre del AWS IoT Greengrass componente que contiene el modelo si utiliza el mismo ejemplo de código de cliente.

Puede crear su componente Hello World AWS IoT Greengrass V2 una vez que haya generado sus códigos RPC G y tenga listo el código de Hello World. Para ello:

Para obtener información detallada sobre cómo crear una receta de Hello World, consulte Crear su primer componente en la AWS IoT Greengrass documentación.