Crea e implementa aplicaciones de inferencia de ML desde cero utilizando Amazon SageMaker

Masteriza la creación e implementación de aplicaciones de inferencia de ML desde cero con Amazon SageMaker

A medida que el aprendizaje automático (ML) se vuelve más común y se adopta más ampliamente, las aplicaciones de inferencia impulsadas por ML se están volviendo cada vez más comunes para resolver una variedad de problemas comerciales complejos. La solución a estos problemas comerciales complejos a menudo requiere el uso de múltiples modelos y pasos de ML. Esta publicación le muestra cómo construir y alojar una aplicación de ML con contenedores personalizados en Amazon SageMaker.

Amazon SageMaker ofrece algoritmos integrados e imágenes de docker preconstruidas de SageMaker para la implementación de modelos. Sin embargo, si estos no se adaptan a sus necesidades, puede traer sus propios contenedores (BYOC) para alojarlos en Amazon SageMaker.

Existen varios casos de uso en los que los usuarios pueden necesitar BYOC para alojar en Amazon SageMaker.

1. Frameworks o bibliotecas de ML personalizados: Si planea utilizar un framework o biblioteca de ML que no es compatible con los algoritmos integrados de Amazon SageMaker o con los contenedores preconstruidos, entonces necesitará crear un contenedor personalizado.
2. Modelos especializados: Para ciertos dominios o industrias, es posible que necesite arquitecturas de modelo específicas o pasos de preprocesamiento personalizados que no están disponibles en las ofertas integradas de Amazon SageMaker.
3. Algoritmos propietarios: Si ha desarrollado sus propios algoritmos propietarios internamente, entonces necesitará un contenedor personalizado para implementarlos en Amazon SageMaker.
4. Tuberías de inferencia complejas: Si su flujo de trabajo de inferencia de ML implica lógica empresarial personalizada, es decir, una serie de pasos complejos que deben ejecutarse en un orden específico, BYOC puede ayudarlo a gestionar y orquestar estos pasos de manera más eficiente.

Visión general de la solución

En esta solución, mostramos cómo alojar una aplicación de inferencia en serie de ML en Amazon SageMaker con puntos finales en tiempo real utilizando dos contenedores de inferencia personalizados con los últimos paquetes de scikit-learn y xgboost.

• El cucaracha cibernético puede navegar por un laberinto
• ¿Cuál es el salario de un desarrollador de Tableau en India?
• Investigadores de ETH Zurich presentan la arquitectura Fast Feedforward (FFF) un par de la arquitectura Feedforward (FF) que accede a bloques de sus neuronas en tiempo logarítmico.

El primer contenedor utiliza un modelo de scikit-learn para transformar datos sin procesar en columnas con características. Aplica StandardScaler para las columnas numéricas y OneHotEncoder para las columnas categóricas.

El segundo contenedor aloja un modelo pre-entrenado de XGboost (es decir, predictor). El modelo predictor acepta la entrada con características y produce predicciones.

Por último, implementamos el featurizador y el predictor en una tubería de inferencia en serie en un punto final en tiempo real de Amazon SageMaker.

Aquí hay algunas consideraciones diferentes sobre por qué puede querer tener contenedores separados dentro de su aplicación de inferencia.

• Desacoplamiento: los diversos pasos de la tubería tienen un propósito claramente definido y deben ejecutarse en contenedores separados debido a las dependencias subyacentes involucradas. Esto también ayuda a mantener la tubería bien estructurada.
• Frameworks: los diversos pasos de la tubería utilizan frameworks específicos para cada propósito (como scikit o Spark ML) y, por lo tanto, deben ejecutarse en contenedores separados.
• Aislamiento de recursos: los diversos pasos de la tubería tienen requisitos de consumo de recursos variables y, por lo tanto, deben ejecutarse en contenedores separados para obtener más flexibilidad y control.
• Mantenimiento y actualizaciones: desde un punto de vista operativo, esto promueve el aislamiento funcional y puede continuar actualizando o modificando pasos individuales de manera mucho más fácil, sin afectar a otros modelos.

Además, la construcción local de los contenedores individuales ayuda en el proceso iterativo de desarrollo y pruebas con herramientas favoritas y entornos de desarrollo integrados (IDE). Una vez que los contenedores estén listos, puede implementarlos en la nube de AWS para inferencia utilizando los puntos finales de Amazon SageMaker.

La implementación completa, incluidos fragmentos de código, está disponible en este repositorio de Github aquí.

Prerrequisitos

Para probar estos contenedores personalizados de forma local, necesitarás tener instalado Docker Desktop en tu ordenador. También debes estar familiarizado con la creación de contenedores Docker.

También necesitarás una cuenta de AWS con acceso a Amazon SageMaker, Amazon ECR y Amazon S3 para probar esta aplicación de principio a fin.

Asegúrate de tener instaladas las últimas versiones de Boto3 y los paquetes de Python para Amazon SageMaker:

pip install --upgrade boto3 sagemaker scikit-learn

Recorrido de la Solución

Construir el contenedor personalizado de featurizer

Para construir el primer contenedor, el contenedor de featurizer, entrenamos un modelo scikit-learn para procesar características sin procesar en el conjunto de datos abalone. El script de preprocesamiento utiliza SimpleImputer para manejar los valores faltantes, StandardScaler para normalizar las columnas numéricas y OneHotEncoder para transformar las columnas categóricas. Después de ajustar el transformador, guardamos el modelo en formato joblib. Luego comprimimos y subimos este artefacto del modelo guardado a un bucket de Amazon Simple Storage Service (Amazon S3).

A continuación se muestra un fragmento de código de ejemplo que demuestra esto. Consulta featurizer.ipynb para ver la implementación completa:

```pythonnumeric_features = list(feature_columns_names)numeric_features.remove("sex")numeric_transformer = Pipeline(    steps=[        ("imputer", SimpleImputer(strategy="median")),        ("scaler", StandardScaler()),    ])categorical_features = ["sex"]categorical_transformer = Pipeline(    steps=[        ("imputer", SimpleImputer(strategy="constant", fill_value="missing")),        ("onehot", OneHotEncoder(handle_unknown="ignore")),    ])preprocess = ColumnTransformer(    transformers=[        ("num", numeric_transformer, numeric_features),        ("cat", categorical_transformer, categorical_features),    ])# Llama a fit en ColumnTransformer para ajustar todos los transformadores a X, ypreprocessor = preprocess.fit(df_train_val)# Guarda el modelo del procesador en discojoblib.dump(preprocess, os.path.join(model_dir, "preprocess.joblib"))```

Luego, para crear un contenedor de inferencia personalizado para el modelo de featurizer, construimos una imagen Docker con los paquetes nginx, gunicorn, flask, junto con otras dependencias necesarias para el modelo de featurizer.

Nginx, gunicorn y la aplicación Flask servirán como la pila de servidores de modelos en los endpoints en tiempo real de Amazon SageMaker.

Cuando se utilizan contenedores personalizados para hospedar en Amazon SageMaker, debemos asegurarnos de que el script de inferencia realice las siguientes tareas después de ser lanzado dentro del contenedor:

1. Carga del modelo: El script de inferencia (preprocessing.py) debe hacer referencia al directorio /opt/ml/model para cargar el modelo en el contenedor. Los artefactos del modelo en Amazon S3 serán descargados y montados en el contenedor en la ruta /opt/ml/model.
2. Variables de entorno: Para pasar variables de entorno personalizadas al contenedor, debes especificarlas durante el paso de creación del Modelo o durante la creación del Endpoint a partir de un trabajo de entrenamiento.
3. Requisitos de la API: El script de inferencia debe implementar las rutas /ping y /invocations como una aplicación Flask. La API /ping se utiliza para comprobaciones de salud, mientras que la API /invocations maneja las solicitudes de inferencia.
4. Registro: Los registros de salida en el script de inferencia deben escribirse en la salida estándar (stdout) y en los flujos de error estándar (stderr). Estos registros luego se transmiten a Amazon CloudWatch por Amazon SageMaker.

A continuación se muestra un fragmento de preprocessing.py que muestra la implementación de /ping y /invocations.

Consulte preprocessing.py en la carpeta featurizer para obtener una implementación completa.

```pythondef load_model():    # Construir la ruta al archivo del modelo de featurizer    ft_model_path = os.path.join(MODEL_PATH, "preprocess.joblib")    featurizer = None    try:        # Abrir el archivo del modelo y cargar el featurizer usando joblib        with open(ft_model_path, "rb") as f:            featurizer = joblib.load(f)            print("Modelo de featurizer cargado", flush=True)    except FileNotFoundError:        print(f"Error: No se encontró el archivo del modelo de featurizer en {ft_model_path}", flush=True)    except Exception as e:        print(f"Error al cargar el modelo de featurizer: {e}", flush=True)    # Devolver el modelo de featurizer cargado o None si hubo un error    return featurizerdef transform_fn(request_body, request_content_type):    """    Transformar el cuerpo de la solicitud en una matriz numpy utilizable para el modelo.    Esta función toma el cuerpo de la solicitud y el tipo de contenido como entrada y    devuelve una matriz numpy transformada que se puede usar como entrada para el    modelo de predicción.    Parámetros:        request_body (str): El cuerpo de la solicitud que contiene los datos de entrada.        request_content_type (str): El tipo de contenido del cuerpo de la solicitud.    Devoluciones:        data (np.ndarray): Datos de entrada transformados como una matriz numpy.    """    # Definir los nombres de las columnas para los datos de entrada    feature_columns_names = [        "sexo",        "longitud",        "diámetro",        "altura",        "peso_entero",        "peso_desprendido",        "peso_víscera",        "peso_cáscara",    ]    columna_etiqueta = "anillos"    # Comprobar si el tipo de contenido de la solicitud es compatible (texto/csv)    if request_content_type == "texto/csv":        # Cargar el modelo de featurizer        featurizer = load_model()        # Comprobar si el featurizer es un ColumnTransformer        if isinstance(            featurizer, sklearn.compose._column_transformer.ColumnTransformer        ):            print(f"Modelo de featurizer cargado", flush=True)        # Leer los datos de entrada del cuerpo de la solicitud como un archivo CSV        df = pd.read_csv(StringIO(request_body), header=None)        # Asignar los nombres de las columnas en función del número de columnas en los datos de entrada        if len(df.columns) == len(feature_columns_names) + 1:            # Este es un ejemplo etiquetado, incluye la etiqueta de los anillos            df.columns = feature_columns_names + [columna_etiqueta]        elif len(df.columns) == len(feature_columns_names):            # Este es un ejemplo sin etiqueta.            df.columns = feature_columns_names        # Transformar los datos de entrada utilizando el featurizer        data = featurizer.transform(df)        # Devolver los datos transformados como una matriz numpy        return data    else:        # Lanzar un error si el tipo de contenido no es compatible        raise ValueError("Tipo de contenido no compatible: {}".format(request_content_type))@app.route("/ping", methods=["GET"])def ping():    # Comprobar si se puede cargar el modelo, establecer el estado en consecuencia    featurizer = load_model()    status = 200 if featurizer is not None else 500    # Devolver la respuesta con el código de estado determinado    return flask.Response(response="\n", status=status, mimetype="application/json")@app.route("/invocations", methods=["POST"])def invocations():    # Convertir de JSON a diccionario    print(f"Featurizer: recibido tipo de contenido: {flask.request.content_type}")    if flask.request.content_type == "texto/csv":        # Decodificar los datos de entrada y transformarlos        input = flask.request.data.decode("utf-8")        transformed_data = transform_fn(input, flask.request.content_type)        # Formatear transformed_data en una cadena CSV        csv_buffer = io.StringIO()        csv_writer = csv.writer(csv_buffer)        for row in transformed_data:            csv_writer.writerow(row)        csv_buffer.seek(0)        # Devolver los datos transformados como una cadena CSV en la respuesta        return flask.Response(response=csv_buffer, status=200, mimetype="texto/csv")    else:        print(f"Recibido: {flask.request.content_type}", flush=True)        return flask.Response(            response="Transformador: Este predictor solo admite datos CSV",            status=415,            mimetype="texto/plain",        )```

Construir una imagen de Docker con featurizer y stack de servicio de modelo

Ahora vamos a construir un Dockerfile utilizando una imagen base personalizada e instalar las dependencias requeridas.

Para esto, usamos python:3.9-slim-buster como imagen base. Puedes cambiar esto por cualquier otra imagen base relevante para tu caso de uso.

Luego copiamos la configuración de nginx, el archivo del servidor web gateway de gunicorn y el script de inferencia al contenedor. También creamos un script de Python llamado “serve” que inicia los procesos de nginx y gunicorn en segundo plano y establece el script de inferencia (es decir, la aplicación Flask “preprocessing.py”) como el punto de entrada para el contenedor.

Aquí hay un fragmento del Dockerfile para alojar el modelo de procesamiento de características. Para ver la implementación completa, consulta el Dockerfile en la carpeta featurizer.

```dockerFROM python:3.9-slim-buster…# Copia requirements.txt a la carpeta /opt/programCOPY requirements.txt /opt/program/requirements.txt# Instala los paquetes listados en requirements.txtRUN pip3 install --no-cache-dir -r /opt/program/requirements.txt# Copia el contenido de la carpeta code/ a /opt/programCOPY code/ /opt/program/# Establece el directorio de trabajo en /opt/program que contiene los scripts serve e inference.pyWORKDIR /opt/program# Expone el puerto 8080 para el servicioEXPOSE 8080ENTRYPOINT ["python"]# serve es un script de Python en la carpeta code/ que inicia los procesos de nginx y gunicornCMD [ "serve" ]```

Prueba la imagen personalizada de inferencia con el procesador de características de forma local

Ahora, compila y prueba el contenedor de inferencia personalizado con el procesador de características de forma local, utilizando el modo local de SageMaker de Amazon. El modo local es perfecto para probar tus scripts de procesamiento, entrenamiento e inferencia sin lanzar trabajos en Amazon SageMaker. Después de confirmar los resultados de tus pruebas locales, puedes adaptar fácilmente los scripts de entrenamiento e inferencia para su implementación en Amazon SageMaker con cambios mínimos.

Para probar la imagen personalizada del procesador de características de forma local, primero construye la imagen utilizando el Dockerfile definido anteriormente. Luego, inicia un contenedor montando el directorio que contiene el modelo del procesador de características (preprocess.joblib) en el directorio /opt/ml/model dentro del contenedor. Además, mapea el puerto 8080 del contenedor al host.

Una vez iniciado el contenedor, puedes enviar solicitudes de inferencia a http://localhost:8080/invocations.

Para compilar e iniciar el contenedor, abre una terminal y ejecuta los siguientes comandos.

Ten en cuenta que debes reemplazar <IMAGE_NAME>, como se muestra en el siguiente código, por el nombre de imagen de tu contenedor.

```shelldocker build -t <IMAGE_NAME> .``````shelldocker run –rm -v $(pwd)/models:/opt/ml/model -p 8080:8080 <IMAGE_NAME>```

Después de que el contenedor esté en funcionamiento, puedes probar las rutas /ping y /invocations usando comandos curl.

Ejecuta los siguientes comandos desde una terminal:

```shell# prueba la ruta /ping en el endpoint localcurl http://localhost:8080/ping# envía una cadena CSV sin procesar a /invocations. El endpoint debería devolver los datos transformadoscurl --data-raw 'I,0.365,0.295,0.095,0.25,0.1075,0.0545,0.08,9.0' -H 'Content-Type: text/csv' -v http://localhost:8080/invocations```

Cuando se envía datos sin procesar a http://localhost:8080/invocations, el endpoint responde con los datos transformados.

Deberías ver una respuesta similar a la siguiente:

“`shell* Intentando 127.0.0.1:8080…* Conectado a localhost (127.0.0.1) puerto 8080 (#0)> POST /invocations HTTP/1.1> Host: localhost: 8080> User-Agent: curl/7.87.0> Aceptar: */*> Content-Type: text/csv> Longitud del contenido: 47>* Marcar el paquete como no compatible con el uso múltiple> HTTP/1.1 200 OK> Servidor: nginx/1.14.2> Fecha: Dom, 09 Abr 2023 20:47:48 GMT> Content-Type: text/csv; charset=utf-8> Longitud del contenido: 150> Conexión: mantener-viva-1.3317586042173168, -1.1425409076053987, -1.0579488602777858, -1.177706547272754, -1.130662184748842,* Conexión #0 al host localhost dejó intacta“`

Ahora terminamos el contenedor en ejecución, y luego etiquetamos y empujamos la imagen personalizada local a un repositorio privado de Amazon Elastic Container Registry (Amazon ECR).

Consulte los siguientes comandos para iniciar sesión en Amazon ECR, que etiqueta la imagen local con la ruta completa de la imagen de Amazon ECR y luego empuja la imagen a Amazon ECR. Asegúrese de reemplazar las variables de región y cuenta para que coincida con su entorno.

```shell# iniciar sesión en ecr con sus credencialesaws ecr get-login-password - -region "${región}" |\docker login - -username AWS - -password-stdin ${cuenta}".dkr.ecr."${región}".amazonaws.com# etiquetar y empujar la imagen al Amazon ECR privadodocker tag ${imagen} ${nombre_completo}docker push ${nombre_completo}```

Consulte los comandos de la Interfaz de línea de comandos de Amazon Web Services (CLI de AWS) para obtener más información sobre cómo crear un repositorio y empujar una imagen a Amazon ECR.

Paso opcional

Opcionalmente, podría realizar una prueba en vivo implementando el modelo de featurización en un punto final en tiempo real con la imagen de Docker personalizada en Amazon ECR. Consulte el cuaderno featurizer.ipynb para obtener la implementación completa de la construcción, prueba y empuje de la imagen personalizada a Amazon ECR.

Amazon SageMaker inicializa el punto final de inferencia y copia los artefactos del modelo al directorio /opt/ml/model dentro del contenedor. Consulte Cómo carga SageMaker tus artefactos de modelo.

Construir contenedor predictor XGBoost personalizado

Para construir el contenedor de inferencia XGBoost, seguimos los mismos pasos que seguimos al construir la imagen del contenedor de featurizador:

1. Descargar el modelo pre-entrenado de XGBoost de Amazon S3.
2. Crear el script inference.py que carga el modelo pre-entrenado de XGBoost, convierte los datos de entrada transformados recibidos del featurizador y los convierte al formato XGBoost.DMatrix, ejecuta predict en el booster y devuelve las predicciones en formato JSON.
3. Los scripts y archivos de configuración que forman la pila de servir modelos (es decir, nginx.conf, wsgi.py y serve) siguen siendo los mismos y no necesitan modificaciones.
4. Usamos Ubuntu:18.04 como la imagen base para el Dockerfile. Esto no es un requisito previo. Usamos la imagen base de Ubuntu para demostrar que los contenedores se pueden construir con cualquier imagen base.
5. Los pasos para construir la imagen de Docker personalizada, probar la imagen localmente y enviar la imagen probada a Amazon ECR siguen siendo los mismos que antes.

Por brevedad, como los pasos son similares mostrados anteriormente; sin embargo, solo mostramos el código modificado a continuación.

Primero, el script inference.py. Aquí hay un fragmento que muestra la implementación de /ping y /invocations. Consulte inference.py en la carpeta predictor para ver la implementación completa de este archivo.

```[email protected]("/ping", methods=["GET"])def ping():    """    Verifica la salud del servidor del modelo verificando si el modelo está cargado.    Retorna un código de estado 200 si el modelo se carga correctamente, o un código de estado 500 si hay un error.    Retorna:       flask.Response: Un objeto de respuesta que contiene el código de estado y el tipo de mime.   """    estado = 200 si el modelo no es None else 500    return flask.Response(response="\n", status=estado, mimetype="application/json")@app.route("/invocations", methods=["POST"])def invocations():    """    Maneja las solicitudes de predicción preprocesando los datos de entrada, haciendo predicciones,    y devolviendo las predicciones como un objeto JSON.    Esta función verifica si el tipo de contenido de la solicitud es compatible (text/csv; charset=utf-8),    y si es así, decodifica los datos de entrada, los preprocesa, realiza predicciones y devuelve    las predicciones como un objeto JSON. Si el tipo de contenido no es compatible, se devuelve un código de estado 415.    Retorna:       flask.Response: Un objeto de respuesta que contiene las predicciones, el código de estado y el tipo de mime.   """    print(f"Predictor: se recibió el tipo de contenido: {flask.request.content_type}")    if flask.request.content_type == "text/csv; charset=utf-8":        input = flask.request.data.decode("utf-8")        transformed_data = preprocess(input, flask.request.content_type)        predictions = predict(transformed_data)        # Devuelve las predicciones como un objeto JSON        return json.dumps({"resultado": predictions})    else:        print(f"Recibido: {flask.request.content_type}", flush=True)        return flask.Response(            response=f"XGBPredictor: Este predictor solo admite datos CSV; Recibido: {flask.request.content_type}",            status=415,            mimetype="text/plain",        )```

Aquí hay un fragmento del Dockerfile para alojar el modelo del predictor. Para la implementación completa, consulta Dockerfile en la carpeta del predictor.

```dockerFROM ubuntu:18.04…# instalar las dependencias requeridas incluyendo flask, gunicorn, xgboost, etc.RUN pip3 --no-cache-dir install  flask  gunicorn  gevent  numpy  pandas  xgboost# Copiar el contenido de la carpeta code/ a /opt/programCOPY code /opt/program# Establecer el directorio de trabajo en /opt/program que tiene los scripts serve e inference.pyWORKDIR /opt/program# Exponer el puerto 8080 para el servicioEXPOSE 8080ENTRYPOINT ["python"]# serve es un script de python en el directorio code/ que inicia los procesos nginx y gunicornCMD ["serve"]```

Luego continuamos construyendo, probando y empujando esta imagen de predictor personalizado a un repositorio privado en Amazon ECR. Consulta predictor.ipynb para obtener la implementación completa de la construcción, pruebas y empuje de la imagen personalizada a Amazon ECR.

Implementar un flujo de inferencia en serie

Después de probar las imágenes del featurizador y del predictor y empujarlas a Amazon ECR, ahora subimos nuestros artefactos de modelo a un bucket de Amazon S3.

Luego, creamos dos objetos de modelo: uno para el featurizador (es decir, preprocess.joblib) y otro para el predictor (es decir, xgboost-model) especificando la URI de la imagen personalizada que creamos anteriormente.

Aquí hay un fragmento que muestra esto. Consulta serial-inference-pipeline.ipynb para obtener la implementación completa.

```pythonsuffix = f"{str(uuid4())[:5]}-{datetime.now().strftime('%d%b%Y')}"# Modelo featurizador (Modelo SKLearn)image_name = "<NOMBRE_IMAGEN_FEATURIZER>"sklearn_image_uri = f"{account_id}.dkr.ecr.{region}.amazonaws.com/{image_name}:latest"featurizer_model_name = f"<NOMBRE_MODELO_FEATURIZER>-{suffix}"print(f"Creando modelo featurizer: {featurizer_model_name}")sklearn_model = Model(    image_uri=featurizer_ecr_repo_uri,    name=featurizer_model_name,    model_data=featurizer_model_data,    role=role,)# Nombre completo del repositorio ECRpredictor_image_name = "<NOMBRE_IMAGEN_PREDICTOR>"predictor_ecr_repo_uri= f"{account_id}.dkr.ecr.{region}.amazonaws.com/{predictor_image_name}:latest"# Modelo Predictor (Modelo XGBoost)predictor_model_name = f"""<NOMBRE_MODELO_PREDICTOR>-{suffix}"print(f"Creando modelo predictor: {predictor_model_name}")xgboost_model = Model(    image_uri=predictor_ecr_repo_uri,    name=predictor_model_name,    model_data=predictor_model_data,    role=role,)```

Ahora, para implementar estos contenedores de manera serial, primero creamos un objeto PipelineModel y pasamos el modelo featurizer y el modelo predictor a un objeto de lista en Python en el mismo orden.

Luego, llamamos al método .deploy() en el PipelineModel especificando el tipo y la cantidad de instancias.

```pythonfrom sagemaker.pipeline import PipelineModelpipeline_model_name = f"Abalone-pipeline-{suffix}"pipeline_model = PipelineModel(    name=pipeline_model_name,    role=role,    models=[sklearn_model, xgboost_model],    sagemaker_session=sm_session,)print(f"Implementando el modelo de pipeline {pipeline_model_name}...")predictor = pipeline_model.deploy(    initial_instance_count=1,    instance_type="ml.m5.xlarge",)```

En esta etapa, Amazon SageMaker implementa el pipeline de inferencia serial en un endpoint en tiempo real. Esperamos a que el endpoint esté InService.

Ahora podemos probar el endpoint enviando algunas solicitudes de inferencia a este endpoint en vivo.

Consulte serial-inference-pipeline.ipynb para ver la implementación completa.

Limpieza

Después de terminar las pruebas, siga las instrucciones de la sección de limpieza del cuaderno para eliminar los recursos provisionados en este post y evitar cargos innecesarios. Consulte Amazon SageMaker Pricing para obtener detalles sobre el costo de las instancias de inferencia.

```python# Delete endpoint, modeltry:    print(f"Eliminando modelo: {pipeline_model_name}")    predictor.delete_model()except Exception as e:    print(f"Error al eliminar el modelo: {pipeline_model_name}\n{e}")    passtry:    print(f"Eliminando endpoint: {endpoint_name}")    predictor.delete_endpoint()except Exception as e:    print(f"Error al eliminar el EP: {endpoint_name}\n{e}")    pass```

Conclusión

En este post, mostré cómo podemos construir e implementar una aplicación de inferencia de ML en serie utilizando contenedores de inferencia personalizados en endpoints en tiempo real en Amazon SageMaker.

Esta solución demuestra cómo los clientes pueden traer sus propios contenedores personalizados para alojar en Amazon SageMaker de manera rentable. Con la opción BYOC, los clientes pueden construir y adaptar rápidamente sus aplicaciones de ML para implementarlos en Amazon SageMaker.

Te animamos a probar esta solución con un conjunto de datos relevante para los indicadores clave de rendimiento (KPI) de tu negocio. Puedes consultar la solución completa en este repositorio de GitHub.

Referencias

• Patrones de hospedaje de modelos en Amazon SageMaker
• Amazon SageMaker Bring your own containers
• Hospedaje de modelos como pipeline de inferencia en serie en Amazon SageMaker

We will continue to update Zepes; if you have any questions or suggestions, please contact us!