Acelere su ciclo de vida de ML utilizando el nuevo y mejorado SDK de Python de Amazon SageMaker – Parte 2: ModelBuilder

En Parte 1 de esta serie, presentamos la clase ModelTrainer recientemente lanzada en el Amazon SageMaker Python SDK y sus beneficios, y le mostró cómo ajustar un modelo Meta Llama 3.1 8B en un conjunto de datos personalizado. En esta publicación, analizamos las mejoras en el Constructor de modelos clase, que le permite implementar sin problemas un modelo desde ModelTrainer en un punto final de SageMaker y proporciona una interfaz única para múltiples configuraciones de implementación.

En noviembre de 2023, lanzamos la clase ModelBuilder (ver Empaquete e implemente modelos más rápido con nuevas herramientas y flujos de trabajo guiados en Amazon SageMaker y Empaquete e implemente ML y LLM clásicos fácilmente con Amazon SageMaker, parte 1: Mejoras de PySDK), que redujo la complejidad de la configuración inicial para crear un punto final de SageMaker, como crear una configuración de punto final, elegir el contenedor, serialización y deserialización, y más, y le ayuda a crear un modelo implementable en un solo paso. La reciente actualización mejora la usabilidad de la clase ModelBuilder para una amplia gama de casos de uso, particularmente en el campo en rápida evolución de la IA generativa. En esta publicación, profundizamos en las mejoras realizadas en la clase ModelBuilder y le mostramos cómo implementar sin problemas el modelo ajustado desde Parte 1 a un punto final de SageMaker.

Mejoras a la clase ModelBuilder

Hemos realizado las siguientes mejoras de usabilidad en la clase ModelBuilder:

• Transición perfecta del entrenamiento a la inferencia – ModelBuilder ahora se integra directamente con las interfaces de entrenamiento de SageMaker para garantizar que se calcule automáticamente la ruta correcta del archivo al último artefacto del modelo entrenado, simplificando el flujo de trabajo desde el entrenamiento del modelo hasta la implementación.
• Interfaz de inferencia unificada – Anteriormente, el SDK de SageMaker ofrecía interfaces y flujos de trabajo separados para diferentes tipos de inferencia, como inferencia en tiempo real, por lotes, sin servidor y asincrónica. Para simplificar el proceso de implementación del modelo y brindar una experiencia consistente, hemos mejorado ModelBuilder para que sirva como una interfaz unificada que admita múltiples tipos de inferencia.
• Facilidad de desarrollo, pruebas y transferencia de producción. – Estamos agregando soporte para pruebas en modo local con ModelBuilder para que los usuarios puedan depurar y probar sin esfuerzo sus scripts de procesamiento e inferencia con pruebas locales más rápidas sin incluir un contenedor, y una nueva función que genera la imagen de contenedor más reciente para un marco determinado para que usted no No es necesario actualizar el código cada vez que sale una nueva versión de LMI.
• Preprocesamiento y posprocesamiento de inferencias personalizables – ModelBuilder ahora le permite personalizar los pasos de preprocesamiento y posprocesamiento para la inferencia. Al permitir que los scripts filtren contenido y eliminen información de identificación personal (PII), esta integración agiliza el proceso de implementación, encapsulando los pasos necesarios dentro de la configuración del modelo para una mejor gestión e implementación de modelos con requisitos de inferencia específicos.
• Soporte de evaluación comparativa – El nuevo soporte de evaluación comparativa en ModelBuilder le permite evaluar opciones de implementación, como puntos finales y contenedores, en función de métricas de rendimiento clave, como la latencia y el costo. Con la introducción de una API de evaluación comparativa, puede probar escenarios y tomar decisiones informadas, optimizando sus modelos para obtener el máximo rendimiento antes de la producción. Esto mejora la eficiencia y proporciona implementaciones rentables.

En las siguientes secciones, analizamos estas mejoras con más detalle y demostramos cómo personalizar, probar e implementar su modelo.

Implementación perfecta desde la clase ModelTrainer

ModelBuilder se integra perfectamente con el Entrenador de modelos clase; simplemente puede pasar el objeto ModelTrainer que se usó para entrenar el modelo directamente a ModelBuilder en el parámetro del modelo. Además de ModelTrainer, ModelBuilder también admite la clase Estimator y el resultado de SageMaker Core. TrainingJob.create() y analiza automáticamente los artefactos del modelo para crear un objeto de modelo de SageMaker. Con el encadenamiento de recursos, puede crear e implementar el modelo como se muestra en el siguiente ejemplo. si seguiste Parte 1 de esta serie para afinar un modelo Meta Llama 3.1 8B, puedes pasar el model_trainer objeto de la siguiente manera:

# set container URI
image_uri = "763104351884.dkr.ecr.us-west-2.amazonaws.com/huggingface-pytorch-tgi-inference:2.3.0-tgi2.2.0-gpu-py310-cu121-ubuntu22.04-v2.0"

model_builder = ModelBuilder(
    model=model_trainer,  # ModelTrainer object passed onto ModelBuilder directly
    role_arn=role,
    image_uri=image_uri,
    inference_spec=inf_spec,
    instance_type="ml.g5.2xlarge"
)
# deploy the model
model_builder.build().deploy()

Personaliza el modelo usando InferenceSpec

El InferenceSpec La clase le permite personalizar el modelo proporcionando lógica personalizada para cargar e invocar el modelo, y especificar cualquier lógica de preprocesamiento o postprocesamiento según sea necesario. Para los puntos finales de SageMaker, los scripts de preprocesamiento y posprocesamiento se utilizan a menudo como parte del proceso de inferencia para manejar las tareas que se requieren antes y después de que los datos se envíen al modelo para realizar predicciones, especialmente en el caso de flujos de trabajo complejos o modelos no estándar. El siguiente ejemplo muestra cómo puede especificar la lógica personalizada usando InferenceSpec:

from sagemaker.serve.spec.inference_spec import InferenceSpec

class CustomerInferenceSpec(InferenceSpec):
    def load(self, model_dir):
        from transformers import AutoModel
        return AutoModel.from_pretrained(HF_TEI_MODEL, trust_remote_code=True)

    def invoke(self, x, model):
        return model.encode(x)

    def preprocess(self, input_data):
        return json.loads(input_data)["inputs"]

    def postprocess(self, predictions):
        assert predictions is not None
        return predictions

Prueba usando modo local y en proceso

Implementar un modelo entrenado en un punto final de SageMaker implica crear un modelo de SageMaker y configurar el punto final. Esto incluye el script de inferencia, cualquier serialización o deserialización requerida, la ubicación del artefacto del modelo en Servicio de almacenamiento simple de Amazon (Amazon S3), el URI de la imagen del contenedor, el tipo y recuento de instancia correctos, y más. Los profesionales del aprendizaje automático (ML) deben iterar sobre estas configuraciones antes de implementar finalmente el punto final en SageMaker para realizar inferencias. ModelBuilder ofrece dos modos para la creación rápida de prototipos:

• En modo proceso – En este caso las inferencias se hacen directamente dentro del mismo proceso de inferencia. Esto es muy útil para probar rápidamente la lógica de inferencia proporcionada a través de InferenceSpec y proporciona retroalimentación inmediata durante la experimentación.
• modo local – El modelo se implementa y ejecuta como un contenedor local. Esto se logra configurando el modo en LOCAL_CONTAINER cuando construyes el modelo. Esto resulta útil para imitar el mismo entorno que el punto final de SageMaker. Consulte lo siguiente computadora portátil por ejemplo.

El siguiente código es un ejemplo de ejecución de inferencia en modo de proceso, con una configuración personalizada. InferenceSpec:

from sagemaker.serve.spec.inference_spec import InferenceSpec
from transformers import pipeline
from sagemaker.serve import Mode
from sagemaker.serve.builder.schema_builder import SchemaBuilder
from sagemaker.serve.builder.model_builder import ModelBuilder

value: str = "Girafatron is obsessed with giraffes, the most glorious animal on the face of this Earth. Giraftron believes all other animals are irrelevant when compared to the glorious majesty of the giraffe.\nDaniel: Hello, Girafatron!\nGirafatron:"
schema = SchemaBuilder(value,
            {"generated_text": "Girafatron is obsessed with giraffes, the most glorious animal on the face of this Earth. Giraftron believes all other animals are irrelevant when compared to the glorious majesty of the giraffe.\\nDaniel: Hello, Girafatron!\\nGirafatron: Hi, Daniel. I was just thinking about how magnificent giraffes are and how they should be worshiped by all.\\nDaniel: You and I think alike, Girafatron. I think all animals should be worshipped! But I guess that could be a bit impractical...\\nGirafatron: That\'s true. But the giraffe is just such an amazing creature and should always be respected!\\nDaniel: Yes! And the way you go on about giraffes, I could tell you really love them.\\nGirafatron: I\'m obsessed with them, and I\'m glad to hear you noticed!\\nDaniel: I\'"})

# custom inference spec with hugging face pipeline
class MyInferenceSpec(InferenceSpec):
    def load(self, model_dir: str):
        ...
    def invoke(self, input, model):
        ...
    def preprocess(self, input_data):
        ...
    def postprocess(self, predictions):
        ...
        
inf_spec = MyInferenceSpec()

# Build ModelBuilder object in IN_PROCESS mode
builder = ModelBuilder(inference_spec=inf_spec,
                       mode=Mode.IN_PROCESS,
                       schema_builder=schema
                      )
                      
# Build and deploy the model
model = builder.build()
predictor=model.deploy()

# make predictions
predictor.predict("How are you today?")

Como siguientes pasos, puede probarlo en modo contenedor local como se muestra en el siguiente código, agregando el image_uri. Necesitará incluir el model_server argumento cuando se incluye el image_uri.

image_uri = '763104351884.dkr.ecr.us-west-2.amazonaws.com/huggingface-pytorch-inference:2.0.0-transformers4.28.1-gpu-py310-cu118-ubuntu20.04'

builder = ModelBuilder(inference_spec=inf_spec,
                       mode=Mode.LOCAL_CONTAINER,  # you can change it to Mode.SAGEMAKER_ENDPOINT for endpoint deployment
                       schema_builder=schema,
                       image_uri=image,
                       model_server=ModelServer.TORCHSERVE
                      )

model = builder.build()                      
predictor = model.deploy()

predictor.predict("How are you today?")

Implementar el modelo

Cuando se complete la prueba, ahora puede implementar el modelo en un punto final en tiempo real para realizar predicciones actualizando el modo a mode.SAGEMAKER_ENDPOINT y proporcionando un tipo y tamaño de instancia:

sm_predictor = model.deploy(
    initial_instance_count=1,
    instance_type="ml.g5.2xlarge",
    mode=Mode.SAGEMAKER_ENDPOINT,
    role=execution_role,
)

sm_predictor.predict("How is the weather?")

Además de la inferencia en tiempo real, SageMaker admite modos de implementación de inferencia sin servidor, inferencia asincrónica e inferencia por lotes. También puedes usar InferenceComponents para abstraer sus modelos y asignar CPU, GPU, aceleradores y políticas de escalado por modelo. Para obtener más información, consulte Reduzca los costos de implementación de modelos en un 50 % en promedio utilizando las funciones más recientes de Amazon SageMaker..

Después de tener el ModelBuilder objeto, puede implementar cualquiera de estas opciones simplemente agregando las configuraciones de inferencia correspondientes al implementar el modelo. De forma predeterminada, si no se proporciona el modo, el modelo se implementa en un en tiempo real punto final. Los siguientes son ejemplos de otras configuraciones:

from sagemaker.serverless.serverless_inference_config import ServerlessInferenceConfig
predictor = model_builder.deploy(
    endpoint_name="serverless-endpoint",
    inference_config=ServerlessInferenceConfig(memory_size_in_mb=2048))

from sagemaker.async_inference.async_inference_config import AsyncInferenceConfig
from sagemaker.s3_utils import s3_path_join

predictor = model_builder.deploy(
    endpoint_name="async-endpoint",
    inference_config=AsyncInferenceConfig(
        output_path=s3_path_join("s3://", bucket, "async_inference/output")))

from sagemaker.batch_inference.batch_transform_inference_config import BatchTransformInferenceConfig

transformer = model_builder.deploy(
    endpoint_name="batch-transform-job",
    inference_config=BatchTransformInferenceConfig(
        instance_count=1,
        instance_type="ml.m5.large",
        output_path=s3_path_join("s3://", bucket, "batch_inference/output"),
        test_data_s3_path = s3_test_path
    ))
print(transformer)

• Implementar un multimodelo punto final usando InferenceComponent:

from sagemaker.compute_resource_requirements.resource_requirements import ResourceRequirements

predictor = model_builder.deploy(
    endpoint_name="multi-model-endpoint",
    inference_config=ResourceRequirements(
        requests={
            "num_cpus": 0.5,
            "memory": 512,
            "copies": 2,
        },
        limits={},
))

Limpiar

Si creó algún punto final al seguir esta publicación, incurrirá en cargos mientras esté en funcionamiento. Como práctica recomendada, elimine los puntos finales si ya no son necesarios, ya sea utilizando el Consola de administración de AWSo usando el siguiente código:

predictor.delete_model() 
predictor.delete_endpoint()

Conclusión

En esta serie de dos partes, presentamos las mejoras de ModelTrainer y ModelBuilder en SageMaker Python SDK. Ambas clases tienen como objetivo reducir la complejidad y la sobrecarga cognitiva de los científicos de datos, proporcionándole una interfaz sencilla e intuitiva para entrenar e implementar modelos, tanto localmente en sus portátiles de SageMaker como en puntos finales remotos de SageMaker.

Le recomendamos que pruebe las mejoras del SDK de SageMaker (SageMaker Core, ModelTrainer y ModelBuilder) consultando el Documentación del SDK y cuadernos de muestra sobre el repositorio de GitHub¡Y déjanos saber tu opinión en los comentarios!

Acerca de los autores

Durga Sury es arquitecto senior de soluciones en el equipo de Amazon SageMaker. Durante los últimos cinco años, ha trabajado con varios clientes empresariales para configurar una plataforma AI/ML segura y escalable construida en SageMaker.

Shweta Singh es gerente senior de productos en el equipo de la plataforma Amazon SageMaker Machine Learning (ML) en AWS, y lidera el SDK de SageMaker Python. Ha trabajado en varios puestos de productos en Amazon durante más de 5 años. Tiene una licenciatura en Ingeniería Informática y una Maestría en Ciencias en Ingeniería Financiera, ambas de la Universidad de Nueva York.