Crea un modelo en Amazon SageMaker con ModelBuilder

La preparación del modelo para su implementación en un SageMaker punto final requiere varios pasos, como elegir una imagen del modelo, configurar la configuración del punto final, codificar las funciones de serialización y deserialización para transferir datos hacia y desde el servidor y el cliente, identificar las dependencias del modelo y cargarlos en Amazon S3. ModelBuilderpuede reducir la complejidad de la configuración y el despliegue iniciales para ayudarle a crear un modelo desplegable en un solo paso.

ModelBuilderrealiza las siguientes tareas por usted:

• Convierte los modelos de aprendizaje automático entrenados con varios marcos, como XGBoost, o PyTorch en modelos desplegables en un solo paso.

• Realiza una selección automática de contenedores en función del marco del modelo para que no tenga que especificar el contenedor manualmente. Aún puedes traer tu propio contenedor pasando tu propio URI aModelBuilder.

• Se encarga de la serialización de los datos en el lado del cliente antes de enviarlos al servidor para deducir y deserializar los resultados devueltos por el servidor. Los datos se formatean correctamente sin procesamiento manual.

• Permite la captura automática de las dependencias y empaqueta el modelo según las expectativas del servidor modelo. ModelBuilderLa captura automática de las dependencias es el mejor enfoque para cargar las dependencias de forma dinámica. (Le recomendamos que pruebe la captura automática de forma local y actualice las dependencias para adaptarla a sus necesidades).

• Para los casos de uso de modelos de lenguaje (LLM) de gran tamaño, si lo desea, puede realizar ajustes de parámetros locales de las propiedades de servidor que se pueden implementar para mejorar el rendimiento cuando se alojan en un SageMaker punto final.

• Es compatible con la mayoría de los modelos de servidores y contenedores más populares TorchServe, como Triton, DJLServing y TGI Container.

Cree su modelo con ModelBuilder

ModelBuilderes una clase de Python que toma un modelo de marco, como XGBoost o una especificación de inferencia especificada por el usuario PyTorch, y lo convierte en un modelo desplegable. ModelBuilderproporciona una función de compilación que genera los artefactos para su despliegue. El artefacto de modelo generado es específico del servidor de modelos, que también se puede especificar como una de las entradas. Para obtener más información sobre la ModelBuilder clase, consulte ModelBuilder.

El siguiente diagrama ilustra el flujo de trabajo general de creación de modelos cuando se utilizaModelBuilder. ModelBuilderacepta un modelo o una especificación de inferencia junto con su esquema para crear un modelo desplegable que pueda probarse localmente antes del despliegue.

ModelBuilderpuede gestionar cualquier personalización que desee aplicar. Sin embargo, para implementar un modelo de marco, el creador del modelo espera como mínimo un modelo, una muestra de entrada y salida y la función. En el siguiente ejemplo de código, ModelBuilder se llama con un modelo de marco y una instancia SchemaBuilder con argumentos mínimos (para deducir las funciones correspondientes para serializar y deserializar la entrada y la salida del punto final). No se especifica ningún contenedor ni se transfiere ninguna dependencia empaquetada; estos recursos se deducen SageMaker automáticamente al crear el modelo.

from sagemaker.serve.builder.model_builder import ModelBuilder
from sagemaker.serve.builder.schema_builder import SchemaBuilder

model_builder = ModelBuilder(
    model=model,
    schema_builder=SchemaBuilder(input, output),
    role_arn="execution-role",
)

El siguiente ejemplo de código se invoca ModelBuilder con una especificación de inferencia (como una InferenceSpec instancia) en lugar de un modelo, con personalización adicional. En este caso, la llamada al creador de modelos incluye una ruta para almacenar los artefactos del modelo y también activa la captura automática de todas las dependencias disponibles. Para obtener más información al respectoInferenceSpec, consulte. Personalice la carga del modelo y la gestión de las solicitudes

model_builder = ModelBuilder(
    mode=Mode.LOCAL_CONTAINER,
    model_path=model-artifact-directory,
    inference_spec=your-inference-spec,
    schema_builder=SchemaBuilder(input, output),
    role_arn=execution-role,
    dependencies={"auto": True}
)

Defina los métodos de serialización y deserialización

Al invocar un SageMaker punto final, los datos se envían a través de cargas HTTP con diferentes tipos de MIME. Por ejemplo, una imagen enviada al punto final para su inferencia debe convertirse en bytes en el lado del cliente y enviarse a través de una carga útil HTTP al punto final. Cuando el punto final recibe la carga útil, debe deserializar la cadena de bytes para devolverla al tipo de datos esperado por el modelo (también conocida como deserialización del lado del servidor). Una vez que el modelo finalice la predicción, los resultados también deben serializarse en bytes que se puedan enviar al usuario o al cliente a través de la carga útil HTTP. Una vez que el cliente recibe los datos de bytes de respuesta, debe realizar una deserialización del lado del cliente para volver a convertir los datos de bytes al formato de datos esperado, como JSON. Como mínimo, debe convertir los datos para las siguientes tareas:

1. Serialización de la solicitud de inferencia (gestionada por el cliente)

2. Deserialización de las solicitudes de inferencia (gestionada por el servidor o el algoritmo)

3. Invocar el modelo contra la carga útil y devolver la carga útil de respuesta

4. Serialización de la respuesta a la inferencia (gestionada por el servidor o el algoritmo)

5. Deserialización de la respuesta de inferencia (gestionada por el cliente)

El siguiente diagrama muestra los procesos de serialización y deserialización que se producen cuando se invoca el punto final.

Al proporcionar una muestra de entrada y salidaSchemaBuilder, el generador de esquemas genera las funciones de clasificación correspondientes para serializar y deserializar la entrada y la salida. Puede personalizar aún más sus funciones de serialización con. CustomPayloadTranslator Pero en la mayoría de los casos, un serializador simple como el siguiente funcionaría:

input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)

Para obtener más información al respectoSchemaBuilder, consulte. SchemaBuilder

En el siguiente fragmento de código se describe un ejemplo en el que se desean personalizar las funciones de serialización y deserialización en los lados del cliente y del servidor. Puede definir sus propios traductores de solicitudes y respuestas con CustomPayloadTranslator estos traductores y pasarlos a ellos. SchemaBuilder

Al incluir las entradas y salidas con los traductores, el creador del modelo puede extraer el formato de datos que espera el modelo. Por ejemplo, supongamos que la entrada de muestra es una imagen sin procesar y sus traductores personalizados recortan la imagen y la envían al servidor como un tensor. ModelBuildernecesita tanto la entrada sin procesar como cualquier código personalizado de preprocesamiento o posprocesamiento para obtener un método que convierta los datos tanto del lado del cliente como del servidor.

from sagemaker.serve import CustomPayloadTranslator

# request translator
class MyRequestTranslator(CustomPayloadTranslator):
    # This function converts the payload to bytes - happens on client side
    def serialize_payload_to_bytes(self, payload: object) -> bytes:
        # converts the input payload to bytes
        ... ...
        return  //return object as bytes

    # This function converts the bytes to payload - happens on server side
    def deserialize_payload_from_stream(self, stream) -> object:
        # convert bytes to in-memory object
        ... ...
        return //return in-memory object

# response translator
class MyResponseTranslator(CustomPayloadTranslator):
    # This function converts the payload to bytes - happens on server side
    def serialize_payload_to_bytes(self, payload: object) -> bytes:
        # converts the response payload to bytes
        ... ...
        return //return object as bytes

    # This function converts the bytes to payload - happens on client side
    def deserialize_payload_from_stream(self, stream) -> object:
        # convert bytes to in-memory object
        ... ...
        return //return in-memory object

Al crear el SchemaBuilder objeto, se pasa el ejemplo de entrada y salida junto con los traductores personalizados previamente definidos, como se muestra en el siguiente ejemplo:

my_schema = SchemaBuilder(
    sample_input=image,
    sample_output=output,
    input_translator=MyRequestTranslator(),
    output_translator=MyResponseTranslator()
)

A continuación, se pasan al objeto los ejemplos de entrada y salida, junto con los traductores personalizados definidos anteriormente. SchemaBuilder

my_schema = SchemaBuilder(
    sample_input=image,
    sample_output=output,
    input_translator=MyRequestTranslator(),
    output_translator=MyResponseTranslator()
)

En las siguientes secciones se explica en detalle cómo crear un modelo con sus clases auxiliares ModelBuilder y cómo utilizarlas para personalizar la experiencia según su caso de uso.

Personalice la carga del modelo y la gestión de las solicitudes

Proporcionar su propio código de inferencia InferenceSpec ofrece una capa adicional de personalización. Con élInferenceSpec, puede personalizar la forma en que se carga el modelo y la forma en que gestiona las solicitudes de inferencia entrantes, omitiendo sus mecanismos predeterminados de gestión de carga e inferencias. Esta flexibilidad es especialmente beneficiosa cuando se trabaja con modelos no estándar o canalizaciones de inferencia personalizadas. Puede personalizar el invoke método para controlar la forma en que el modelo preprocesa y postprocesa las solicitudes entrantes. El invoke método garantiza que el modelo gestione las solicitudes de inferencia correctamente. El siguiente ejemplo se utiliza InferenceSpec para generar un modelo con la HuggingFace canalización. Para obtener más información al respectoInferenceSpec, consulte la InferenceSpec.

from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline

class MyInferenceSpec(InferenceSpec):
    def load(self, model_dir: str):
        return pipeline("translation_en_to_fr", model="t5-small")

    def invoke(self, input, model):
        return model(input)

inf_spec = MyInferenceSpec()

model_builder = ModelBuilder(
    inference_spec=your-inference-spec,
    schema_builder=SchemaBuilder(X_test, y_pred)
)

El siguiente ejemplo ilustra una variación más personalizada de un ejemplo anterior. Un modelo se define con una especificación de inferencia que tiene dependencias. En este caso, el código de la especificación de inferencia depende del paquete lang-segment. El argumento for dependencies contiene una sentencia que indica al generador que instale lang-segment mediante Git. Dado que el usuario indica al creador de modelos que instale una dependencia de forma personalizada, la auto clave es False desactivar la captura automática de las dependencias.

model_builder = ModelBuilder(
    mode=Mode.LOCAL_CONTAINER,
    model_path=model-artifact-directory,
    inference_spec=your-inference-spec,
    schema_builder=SchemaBuilder(input, output),
    role_arn=execution-role,
    dependencies={"auto": False, "custom": ["-e git+https://github.com/luca-medeiros/lang-segment-anything.git#egg=lang-sam"],}
)

Cree su modelo e impleméntelo

Llame a la build función para crear su modelo desplegable. En este paso, se crean códigos de inferencia en el directorio de trabajo con el código necesario para crear el esquema, ejecutar la serialización y deserialización de las entradas y salidas y ejecutar otras lógicas personalizadas especificadas por el usuario. inference.py

Como control de integridad, SageMaker empaqueta y selecciona los archivos necesarios para su implementación como parte de la función de compilación. ModelBuilder Durante este proceso, SageMaker también crea la firma HMAC para el archivo pickle y añade la clave secreta en la CreateModelAPI como variable de entorno durante deploy (o). create El lanzamiento del punto final utiliza la variable de entorno para validar la integridad del archivo pickle.

# Build the model according to the model server specification and save it as files in the working directory
model = model_builder.build()

Implemente su modelo con el deploy método existente del modelo. En este paso, SageMaker configura un punto final para alojar el modelo a medida que comience a hacer predicciones sobre las solicitudes entrantes. Si bien ModelBuilder deduce los recursos de punto final necesarios para implementar su modelo, puede anular esas estimaciones con sus propios valores de parámetros. En el siguiente ejemplo, SageMaker se indica cómo implementar el modelo en una sola ml.c6i.xlarge instancia. Un modelo creado a partir de ModelBuilder él permite el registro en tiempo real durante la implementación como una función adicional.

predictor = model.deploy(
    initial_instance_count=1,
    instance_type="ml.c6i.xlarge"
)

Si desea tener un control más preciso sobre los recursos de punto final asignados a su modelo, puede utilizar un objeto. ResourceRequirements Con el ResourceRequirements objeto, puede solicitar una cantidad mínima de CPU, aceleradores y copias de los modelos que desee implementar. También puede solicitar un límite de memoria mínimo y máximo (en MB). Para utilizar esta función, debe especificar el tipo de punto final comoEndpointType.INFERENCE_COMPONENT_BASED. En el siguiente ejemplo, se solicitan cuatro aceleradores, un tamaño de memoria mínimo de 1024 MB y una copia del modelo para implementarlos en un dispositivo de este tipoEndpointType.INFERENCE_COMPONENT_BASED.

resource_requirements = ResourceRequirements(
    requests={
        "num_accelerators": 4,
        "memory": 1024,
        "copies": 1,
    },
    limits={},
)
predictor = model.deploy(
    mode=Mode.SAGEMAKER_ENDPOINT,
    endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED,
    resources=resource_requirements,
    role="role"
)

Traiga su propio contenedor (BYOC)

Si quieres traer tu propio contenedor (extendido desde un SageMaker contenedor), también puedes especificar el URI de la imagen, tal y como se muestra en el siguiente ejemplo. También debe identificar el servidor de modelos que corresponde a la imagen ModelBuilder para generar artefactos específicos del servidor de modelos.

model_builder = ModelBuilder(
    model=model,
    model_server=ModelServer.TORCHSERVE,
    schema_builder=SchemaBuilder(X_test, y_pred),
    image_uri="123123123123.dkr.ecr.ap-southeast-2.amazonaws.com/byoc-image:xgb-1.7-1")
)

ModelBuilder Utilizándolo en modo local

Puede implementar su modelo localmente utilizando el mode argumento para cambiar entre las pruebas locales y el despliegue en un punto final. Debe almacenar los artefactos del modelo en el directorio de trabajo, como se muestra en el siguiente fragmento:

model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")

Pase el objeto modelo, una SchemaBuilder instancia y establezca el modo en. Mode.LOCAL_CONTAINER Cuando llamas a la build función, identifica ModelBuilder automáticamente el contenedor del framework compatible y busca las dependencias. El siguiente ejemplo muestra la creación de modelos con un modelo XGBoost en modo local.

model_builder_local = ModelBuilder(
    model=model,
    schema_builder=SchemaBuilder(X_test, y_pred),
    role_arn=execution-role,
    mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()

Llame a la deploy función para implementarla localmente, como se muestra en el siguiente fragmento. Si especificas parámetros para el tipo o el recuento de instancias, estos argumentos se ignoran.

predictor_local = xgb_local_builder.deploy()

Solución de problemas en el modo local

En función de su configuración local individual, es posible que tenga dificultades para funcionar ModelBuilder sin problemas en su entorno. Consulte la siguiente lista para ver algunos de los problemas a los que puede enfrentarse y cómo resolverlos.

• Ya está en uso: es posible que se produzca un Address already in use error. En este caso, es posible que se esté ejecutando un contenedor Docker en ese puerto o que otro proceso lo esté utilizando. Puede seguir el enfoque descrito en la documentación de Linux para identificar el proceso y redirigir correctamente el proceso local del puerto 8080 a otro puerto o limpiar la instancia de Docker.

• Problema de permiso de IAM: es posible que se produzca un problema de permiso al intentar extraer una imagen de Amazon ECR o acceder a Amazon S3. En este caso, diríjase a la función de ejecución del bloc de notas o de la instancia de Studio Classic para comprobar la política SageMakerFullAccess o los permisos de API correspondientes.

• Problema de capacidad de volumen de EBS: si implementas un modelo de lenguaje grande (LLM), es posible que te quedes sin espacio mientras ejecutas Docker en modo local o que tengas limitaciones de espacio en la caché de Docker. En este caso, puede intentar mover el volumen de Docker a un sistema de archivos que tenga suficiente espacio. Para mover el volumen de Docker, complete los siguientes pasos:

  1. Abre un terminal y df ejecútalo para mostrar el uso del disco, como se muestra en el siguiente resultado:

     (python3) sh-4.2$ df
     Filesystem     1K-blocks      Used Available Use% Mounted on
     devtmpfs       195928700         0 195928700   0% /dev
     tmpfs          195939296         0 195939296   0% /dev/shm
     tmpfs          195939296      1048 195938248   1% /run
     tmpfs          195939296         0 195939296   0% /sys/fs/cgroup
     /dev/nvme0n1p1 141545452 135242112   6303340  96% /
     tmpfs           39187860         0  39187860   0% /run/user/0
     /dev/nvme2n1   264055236  76594068 176644712  31% /home/ec2-user/SageMaker
     tmpfs           39187860         0  39187860   0% /run/user/1002
     tmpfs           39187860         0  39187860   0% /run/user/1001
     tmpfs           39187860         0  39187860   0% /run/user/1000

  2. Mueva el directorio Docker predeterminado de /dev/nvme0n1p1 a para /dev/nvme2n1 poder utilizar al máximo el SageMaker volumen de 256 GB. Para obtener más información, consulta la documentación sobre cómo mover tu directorio de Docker.

  3. Detenga Docker con el siguiente comando:

     sudo service docker stop

  4. Añada un daemon.json /etc/docker o añada el siguiente blob JSON al existente.

     {
         "data-root": "/home/ec2-user/SageMaker/{created_docker_folder}"
     }

  5. Mueva el directorio de Docker /var/lib/docker a /home/ec2-user/SageMaker con el siguiente comando:

     sudo rsync -aP /var/lib/docker/ /home/ec2-user/SageMaker/{created_docker_folder}

  6. Inicie Docker con el siguiente comando:

     sudo service docker start

  7. Limpie la papelera con el siguiente comando:

     cd /home/ec2-user/SageMaker/.Trash-1000/files/*
     sudo rm -r *

  8. Si utilizas una instancia de SageMaker bloc de notas, puedes seguir los pasos del archivo de preparación de Docker para preparar Docker para el modo local.

ModelBuilder ejemplos

Para ver más ejemplos de uso ModelBuilder para crear modelos, consulta los ModelBuilderejemplos de libretas.