Realice un seguimiento de sus experimentos de ML de principio a fin con Data Version Control y Amazon SageMaker Experiments

Los científicos de datos a menudo trabajan para comprender los efectos de varias estrategias de preprocesamiento de datos e ingeniería de características en combinación con diferentes arquitecturas de modelos e hiperparámetros. Hacerlo requiere que cubra grandes espacios de parámetros de forma iterativa, y puede ser abrumador realizar un seguimiento de las configuraciones y los resultados ejecutados anteriormente mientras se mantienen reproducibles los experimentos.

Esta publicación lo guía a través de un ejemplo de cómo realizar un seguimiento de sus experimentos en código, datos, artefactos y métricas mediante el uso de Experimentos de Amazon SageMaker junto con Control de versión de datos (DVC). Le mostramos cómo puede usar DVC junto con Amazon SageMaker trabajos de procesamiento y capacitación. Entrenamos diferentes modelos CatBoost en el conjunto de datos de vivienda de California desde el Repositorio StatLiby cambie las estrategias de retención mientras realiza un seguimiento de la versión de datos con DVC. En cada experimento individual, hacemos un seguimiento de los artefactos de entrada y salida, el código y las métricas mediante SageMaker Experiments.

Experimentos de SageMaker

SageMaker Experiments es un servicio de AWS para el seguimiento de experimentos de aprendizaje automático (ML). los SDK de Python para experimentos de SageMaker es una interfaz de alto nivel para este servicio que lo ayuda a realizar un seguimiento de la información del experimento mediante Python.

El objetivo de SageMaker Experiments es simplificar al máximo la creación de experimentos, completarlos con pruebas, agregar información de seguimiento y linaje, y ejecutar análisis en pruebas y experimentos.

Cuando hablamos de los experimentos de SageMaker, nos referimos a los siguientes conceptos:

• Experimento – Una colección de ensayos relacionados. Agrega pruebas a un experimento que desea comparar entre sí.
• Ici – Una descripción de un flujo de trabajo de ML de varios pasos. Cada paso del flujo de trabajo se describe mediante un componente de prueba.
• Componente de prueba – Una descripción de un solo paso en un flujo de trabajo de ML, como limpieza de datos, extracción de características, entrenamiento de modelos o evaluación de modelos.
• Seguimiento – Un administrador de contexto de Python para registrar información sobre un solo componente de prueba (por ejemplo, parámetros, métricas o artefactos).

Control de versión de datos

Data Version Control (DVC) es un nuevo tipo de software de control de versiones de datos, flujo de trabajo y gestión de experimentos que se basa en Git (aunque puede funcionar de forma independiente). DVC reduce la brecha entre los conjuntos de herramientas de ingeniería establecidos y las necesidades de la ciencia de datos, lo que le permite aprovechar las nuevas Características mientras se reutilizan las habilidades y la intuición existentes.

El intercambio de experimentos de ciencia de datos y la colaboración se pueden realizar a través de un flujo de Git normal (confirmaciones, bifurcaciones, etiquetado, solicitudes de extracción) de la misma manera que funciona para los ingenieros de software. Con Git y DVC, los equipos de ciencia de datos y ML pueden crear versiones de experimentos, administrar grandes conjuntos de datos y hacer que los proyectos sean reproducibles.

DVC tiene las siguientes características:

• DVC es un gratuita,, fuente abierta de línea de comandos .
• DVC funciona sobre los repositorios de Git y tiene una interfaz de línea de comandos y un flujo similares a los de Git. DVC también puede funcionar de forma independiente, pero sin control de versiones capacidades.
• El control de versiones de datos se habilita reemplazando archivos grandes, directorios de conjuntos de datos, modelos ML, etc. metarchivos (fácil de manejar con Git). Estos marcadores de posición apuntan a los datos originales, que están desvinculados de la gestión del código fuente.
• Puede usar almacenamiento local o en la nube para almacenar los datos del proyecto separados de su base de código. Así es como los científicos de datos pueden transferir grandes conjuntos de datos o compartir un modelo entrenado en GPU con otros.
• DVC hace que los proyectos de ciencia de datos sean reproducibles al crear tuberías usando gráficos de dependencia implícitos y codificando los datos y artefactos involucrados.
• DVC es independiente de la plataforma. Se ejecuta en todos los principales sistemas operativos (Linux, macOS y Windows) y funciona independientemente de los lenguajes de programación (Python, R, Julia, shell scripts, etc.) o bibliotecas ML (Keras, TensorFlow, PyTorch, Scipy y más) utilizados en el proyecto.
• DVC es rápido para instalar y no requiere infraestructura especial, ni depende de APIs o servicios externos. Es una herramienta CLI independiente.

Experimentos de SageMaker y ejemplo de DVC

Las siguientes Ejemplo de GitHub muestra cómo utilizar DVC en el entorno de SageMaker. En particular, analizamos cómo crear una imagen personalizada con bibliotecas DVC instaladas de forma predeterminada para proporcionar un entorno de desarrollo coherente a sus científicos de datos en Estudio Amazon SageMakery cómo ejecutar DVC junto con la infraestructura administrada de SageMaker para procesamiento y capacitación. Además, mostramos cómo enriquecer la información de seguimiento de SageMaker con información de versiones de datos de DVC y visualizarlos en la consola de Studio.

El siguiente diagrama ilustra la arquitectura y el flujo de trabajo de la solución.

Cree una imagen de Studio personalizada con DVC ya instalado

En este Repositorio GitHub, explicamos cómo crear una imagen personalizada para Studio que ya tiene DVC instalado. La ventaja de crear una imagen y ponerla a disposición de todos los usuarios de Studio es que crea un entorno coherente para los usuarios de Studio, que también pueden ejecutar localmente. Aunque la muestra se basa en Nube de AWS9, también puede compilar el contenedor en su máquina local siempre que tenga Docker instalado y en ejecución. Esta muestra se basa en los siguientes Dockerfile y entorno.yml. La imagen Docker resultante se almacena en Registro de contenedores elásticos de Amazon (Amazon EMR) en su cuenta de AWS. Ver el siguiente código:

# Login to ECR
aws --region ${REGION} ecr get-login-password | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom

# Create the ECR repository
aws --region ${REGION} ecr create-repository --repository-name smstudio-custom

# Build the image - it might take a few minutes to complete this step
docker build . -t ${IMAGE_NAME} -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

# Push the image to ECR
docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/smstudio-custom:${IMAGE_NAME}

Ahora puedes crear un nuevo dominio de Studio or actualizar un dominio de Studio existente que tiene acceso a la imagen de Docker recién creada.

Utilizamos Kit de desarrollo en la nube de AWS (AWS CDK) para crear los siguientes recursos a través de Formación en la nube de AWS:

• Una función de ejecución de SageMaker con los permisos adecuados para su dominio de Studio nuevo o existente
• Una imagen de SageMaker y una versión de imagen de SageMaker de la imagen de Docker conda-env-dvc-kernel que creamos antes
• An AppImageConfig que especifica cómo debe configurarse la puerta de enlace del kernel
• Un usuario de estudio (data-scientist-dvc) con la función de ejecución de SageMaker correcta y la imagen personalizada de Studio disponible

Para obtener instrucciones detalladas, consulte Asociar una imagen personalizada a SageMaker Studio.

ejecutar el laboratorio

Para ejecutar el laboratorio, complete los siguientes pasos:

1. En el dominio de Studio, inicie Studio para el data-scientist-dvc .
2. Elija el ícono de Git, luego elija Clonar un repositorio.
   
3. Introduzca la URL del repositorio (https://github.com/aws-samples/amazon-sagemaker-experiments-dvc-demo) y elige Clon.
4. En el explorador de archivos, elija el amazon-sagemaker-experiments-dvc-demo repositorio.
5. Abra la dvc_sagemaker_script_mode.ipynb cuaderno.
6. Imagen personalizada, elija la imagen conda-env-dvc-kernel.
7. Elige Seleccione.
   

Configurar DVC para el control de versiones de datos

Creamos un subdirectorio donde preparamos los datos: sagemaker-dvc-sample. Dentro de este subdirectorio, inicializamos un nuevo repositorio de Git y configuramos el control remoto en un repositorio que creamos en Compromiso de código de AWS. El objetivo es tener configuraciones DVC y archivos para el seguimiento de datos versionados en este repositorio. Sin embargo, Git ofrece capacidades nativas para administrar subproyectos mediante, por ejemplo, submódulos de git y subárboles de git, y puede ampliar este ejemplo para usar cualquiera de las herramientas mencionadas que mejor se adapten a su flujo de trabajo.

La principal ventaja de usar CodeCommit con SageMaker en nuestro caso es su integración con Gestión de identidades y accesos de AWS (IAM) para autenticación y autorización, lo que significa que podemos usar roles de IAM para enviar y extraer datos sin necesidad de obtener credenciales (o claves SSH). La configuración de los permisos adecuados en la función de ejecución de SageMaker también permite que el cuaderno de Studio y el trabajo de procesamiento y capacitación de SageMaker interactúen de forma segura con CodeCommit.

Aunque puede reemplazar CodeCommit con cualquier otro servicio de control de fuente, como GitHub, Gitlab o Bitbucket, debe considerar cómo manejar las credenciales para su sistema. Una posibilidad es almacenar estas credenciales en Director de secretos de AWS y obtenerlos en tiempo de ejecución desde el cuaderno de Studio, así como desde los trabajos de procesamiento y capacitación de SageMaker.

Procese y entrene con DVC y SageMaker

En esta sección, exploramos dos enfoques diferentes para abordar nuestro problema y cómo podemos realizar un seguimiento de las dos pruebas utilizando SageMaker Experiments de acuerdo con la arquitectura conceptual de alto nivel que le mostramos anteriormente.

Configurar un experimento de SageMaker

Para realizar un seguimiento de esta prueba en SageMaker, debemos crear un experimento. Necesitamos también definir la prueba dentro del experimento. En aras de la simplicidad, solo consideramos una prueba para el experimento, pero puede tener cualquier cantidad de pruebas dentro de un experimento, por ejemplo, si desea probar diferentes algoritmos.

Creamos un experimento llamado DEMO-sagemaker-experiments-dvc con dos ensayos, dvc-trial-single-file y dvc-trial-multi-files, cada uno de los cuales representa una versión diferente del conjunto de datos.

Vamos a crear el DEMO-sagemaker-experiments-dvc experimentar:

from smexperiments.experiment import Experiment
from smexperiments.trial import Trial
from smexperiments.trial_component import TrialComponent
from smexperiments.tracker import Tracker

experiment_name = 'DEMO-sagemaker-experiments-dvc'

# create the experiment if it doesn't exist
try:
    my_experiment = Experiment.load(experiment_name=experiment_name)
    print("existing experiment loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_experiment = Experiment.create(
            experiment_name = experiment_name,
            description = "How to integrate DVC"
        )
        print("new experiment created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Prueba 1: generar archivos únicos para entrenamiento y validación

En esta sección, creamos un script de procesamiento que obtiene los datos sin procesar directamente de Servicio de almacenamiento simple de Amazon (Amazon S3) como entrada; lo procesa para crear los conjuntos de datos de entrenamiento, validación y prueba; y almacena los resultados en Amazon S3 mediante DVC. Además, mostramos cómo puede realizar un seguimiento de los artefactos de salida generados por DVC con SageMaker al ejecutar trabajos de procesamiento y capacitación y a través de SageMaker Experiments.

Primero, creamos el dvc-trial-single-file de prueba y añádalo a la DEMO-sagemaker-experiments-dvc experimento. Al hacerlo, mantenemos todos los componentes del ensayo relacionados con esta prueba organizados de manera significativa.

first_trial_name = "dvc-trial-single-file"

try:
    my_first_trial = Trial.load(trial_name=first_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_first_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=first_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

Use DVC en un trabajo de procesamiento de SageMaker para crear la versión de archivo único

En esta sección, creamos un script de procesamiento que obtiene los datos sin procesar directamente de Amazon S3 como entrada utilizando la capacidad de carga de datos administrados de SageMaker; lo procesa para crear los conjuntos de datos de entrenamiento, validación y prueba; y almacena los resultados en Amazon S3 mediante DVC. Es muy importante comprender que cuando usamos DVC para almacenar datos en Amazon S3 (o extraer datos de Amazon S3), estamos perdiendo las capacidades de carga de datos administrados de SageMaker, lo que puede tener un impacto potencial en el rendimiento y los costos de nuestros trabajos de procesamiento y capacitación. , especialmente cuando se trabaja con conjuntos de datos muy grandes. Para obtener más información sobre las diferentes capacidades del modo de entrada nativo de SageMaker, consulte Acceder a datos de entrenamiento.

Finalmente, unificamos las capacidades de seguimiento de DVC con las capacidades de seguimiento de SageMaker al ejecutar trabajos de procesamiento a través de SageMaker Experiments.

El script de procesamiento espera la dirección del repositorio de Git y la rama que queremos crear para almacenar los metadatos de DVC pasados ​​a través de variables ambientales. Los propios conjuntos de datos se almacenan en Amazon S3 por DVC. Si bien las variables ambientales se rastrean automáticamente en SageMaker Experiments y son visibles en los parámetros del componente de prueba, es posible que deseemos enriquecer los componentes de prueba con más información, que luego estará disponible para su visualización en la interfaz de usuario de Studio mediante un objeto de seguimiento. En nuestro caso, los parámetros de los componentes de prueba incluyen lo siguiente:

• DVC_REPO_URL
• DVC_BRANCH
• USER
• data_commit_hash
• train_test_split_ratio

El script de preprocesamiento clona el repositorio de Git; genera los conjuntos de datos de entrenamiento, validación y prueba; y lo sincroniza usando DVC. Como se mencionó anteriormente, cuando usamos DVC, no podemos aprovechar las capacidades nativas de carga de datos de SageMaker. Aparte de las penalizaciones de rendimiento que podríamos sufrir en grandes conjuntos de datos, también perdemos las capacidades de seguimiento automático de los artefactos de salida. Sin embargo, gracias al rastreador y la API Python de DVC, podemos compensar estas deficiencias, recuperar dicha información en tiempo de ejecución y almacenarla en el componente de prueba con poco esfuerzo. El valor agregado al hacerlo es tener una vista única de los artefactos de entrada y salida que pertenecen a este trabajo de procesamiento específico.

El script completo de preprocesamiento de Python está disponible en el Repositorio GitHub.

with Tracker.load() as tracker:
    tracker.log_parameters({"data_commit_hash": commit_hash})
    for file_type in file_types:
        path = dvc.api.get_url(
            f"{data_path}/{file_type}/california_{file_type}.csv",
            repo=dvc_repo_url,
            rev=dvc_branch
        )
        tracker.log_output(name=f"california_{file_type}",value=path)

SageMaker nos brinda la posibilidad de ejecutar nuestro script de procesamiento en imágenes de contenedores administradas por AWS que están optimizadas para ejecutarse en la infraestructura de AWS. Si nuestro script requiere dependencias adicionales, podemos proporcionar un requirements.txt expediente. Cuando comenzamos el trabajo de procesamiento, SageMaker usa pip-install para instalar todas las bibliotecas que necesitamos (por ejemplo, bibliotecas relacionadas con DVC). Si necesita tener un control más estricto de todas las bibliotecas instaladas en los contenedores, puede traer su propio contenedor en SageMaker, por ejemplo para tratamiento y entrenamiento.

Ahora tenemos todos los ingredientes para ejecutar nuestro trabajo de procesamiento de SageMaker:

• Un script de procesamiento que puede procesar varios argumentos (--train-test-split-ratio) y dos variables ambientales (DVC_REPO_URL y DVC_BRANCH)
• A requiremets.txt presentar
• Un repositorio Git (en CodeCommit)
• Un experimento y prueba de SageMaker

from sagemaker.processing import FrameworkProcessor, ProcessingInput
from sagemaker.sklearn.estimator import SKLearn

dvc_repo_url = "codecommit::{}://sagemaker-dvc-sample".format(region)
dvc_branch = my_first_trial.trial_name

script_processor = FrameworkProcessor(
    estimator_cls=SKLearn,
    framework_version='0.23-1',
    instance_count=1,
    instance_type='ml.m5.xlarge',
    env={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    },
    role=role
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Luego ejecutamos el trabajo de procesamiento con el preprocessing-experiment.py guión, experiment_config, dvc_repo_urly dvc_branch definimos anteriormente.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.2"]
)

El trabajo de procesamiento tarda aproximadamente 5 minutos en completarse. Ahora puede ver los detalles de la prueba para el conjunto de datos de un solo archivo.

La siguiente captura de pantalla muestra dónde puede encontrar la información almacenada dentro de Studio. Tenga en cuenta los valores de dvc-trial-single-file in DVC_BRANCH, DVC_REPO_URLy data_commit_hash en parámetros .

También tenga en cuenta los detalles de entrada y salida en el Los artefactos .

Cree un estimador y ajuste el modelo con una versión de datos de un solo archivo

Para usar la integración de DVC dentro de un trabajo de capacitación de SageMaker, pasamos un dvc_repo_url y dvc_branch como variables ambientales cuando crea el objeto Estimator.

Entrenamos en el dvc-trial-single-file rama primero.

Al extraer datos con DVC, usamos la siguiente estructura de conjunto de datos:

dataset
    |-- train
    |   |-- california_train.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation.csv

Ahora creamos un Estimador Scikit-learn usando el SDK de SageMaker Python. Esto nos permite especificar lo siguiente:

• La ruta al archivo fuente de Python, que debe ejecutarse como punto de entrada al entrenamiento.
• El rol de IAM que controla los permisos para acceder a los datos de Amazon S3 y CodeCommit y ejecutar las funciones de SageMaker.
• Una lista de diccionarios que definen las métricas utilizadas para evaluar los trabajos de entrenamiento.
• El número y tipo de instancias de entrenamiento. Usamos una instancia ml.m5.large.
• Hiperparámetros que se utilizan para el entrenamiento.
• Variables de entorno a utilizar durante el trabajo de entrenamiento. Usamos DVC_REPO_URL, DVC_BRANCHy USER.

metric_definitions = [{'Name': 'median-AE', 'Regex': "AE-at-50th-percentile: ([0-9.]+).*$"}]

hyperparameters={ 
        "learning_rate" : 1,
        "depth": 6
    }
estimator = SKLearn(
    entry_point='train.py',
    source_dir='source_dir',
    role=role,
    metric_definitions=metric_definitions,
    hyperparameters=hyperparameters,
    instance_count=1,
    instance_type='ml.m5.large',
    framework_version='0.23-1',
    base_job_name='training-with-dvc-data',
    environment={
        "DVC_REPO_URL": dvc_repo_url,
        "DVC_BRANCH": dvc_branch,
        "USER": "sagemaker"
    }
)

experiment_config={
    "ExperimentName": my_experiment.experiment_name,
    "TrialName": my_first_trial.trial_name
}

Llamamos al método de ajuste del Estimador con experiment_config que definimos anteriormente para comenzar el entrenamiento.

%%time
estimator.fit(experiment_config=experiment_config)

El trabajo de entrenamiento tarda aproximadamente 5 minutos en completarse. Los registros muestran esas líneas, indicando los archivos extraídos por DVC:

Running dvc pull command
A       train/california_train.csv
A       test/california_test.csv
A       validation/california_validation.csv
3 files added and 3 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train.csv']
Found validation files: ['/opt/ml/input/data/dataset/train/california_train.csv']

Prueba 2: generar múltiples archivos para entrenamiento y validación

Creamos un nuevo dvc-trial-multi-files versión de prueba y agregarlo a la actual DEMO-sagemaker-experiments-dvc experimentar.

second_trial_name = "dvc-trial-multi-files"
try:
    my_second_trial = Trial.load(trial_name=second_trial_name)
    print("existing trial loaded")
except Exception as ex:
    if "ResourceNotFound" in str(ex):
        my_second_trial = Trial.create(
            experiment_name=experiment_name,
            trial_name=second_trial_name,
        )
        print("new trial created")
    else:
        print(f"Unexpected {ex}=, {type(ex)}")
        print("Dont go forward!")
        raise

A diferencia del primer script de procesamiento, ahora creamos varios archivos a partir del conjunto de datos original para entrenamiento y validación, y almacenamos los metadatos de DVC en una rama diferente.

Puede explorar el segundo script Python de preprocesamiento en GitHub.

%%time

script_processor.run(
    code='./source_dir/preprocessing-experiment-multifiles.py',
    dependencies=['./source_dir/requirements.txt'],
    inputs=[ProcessingInput(source=s3_data_path, destination="/opt/ml/processing/input")],
    experiment_config=experiment_config,
    arguments=["--train-test-split-ratio", "0.1"]
)

El trabajo de procesamiento tarda aproximadamente 5 minutos en completarse. Ahora puede ver los detalles de la prueba para el conjunto de datos de varios archivos.

Las siguientes capturas de pantalla muestran dónde puede encontrar la información almacenada dentro de SageMaker Experiments en el Componentes de prueba dentro de la interfaz de usuario de Studio. Tenga en cuenta los valores de dvc-trial-multi-files in DVC_BRANCH, DVC_REPO_URLy data_commit_hash en parámetros .

También puede revisar los detalles de entrada y salida en el Los artefactos .

Ahora entrenamos en el dvc-trial-multi-files rama. Al extraer datos con DVC, usamos la siguiente estructura de conjunto de datos:

dataset
    |-- train
    |   |-- california_train_1.csv
    |   |-- california_train_2.csv
    |   |-- california_train_3.csv
    |   |-- california_train_4.csv
    |   |-- california_train_5.csv
    |-- test
    |   |-- california_test.csv
    |-- validation
    |   |-- california_validation_1.csv
    |   |-- california_validation_2.csv
    |   |-- california_validation_3.csv

De manera similar a como lo hicimos antes, creamos un nuevo Estimador de Scikit-learn con el nombre de prueba dvc-trial-multi-files y comenzar el trabajo de entrenamiento.

%%time

estimator.fit(experiment_config=experiment_config)

El trabajo de entrenamiento tarda aproximadamente 5 minutos en completarse. En la salida de los registros de trabajo de entrenamiento al cuaderno, puede ver esas líneas, que indican los archivos extraídos por DVC:

Running dvc pull command
A       validation/california_validation_2.csv
A       validation/california_validation_1.csv
A       validation/california_validation_3.csv
A       train/california_train_4.csv
A       train/california_train_5.csv
A       train/california_train_2.csv
A       train/california_train_3.csv
A       train/california_train_1.csv
A       test/california_test.csv
9 files added and 9 files fetched
Starting the training.
Found train files: ['/opt/ml/input/data/dataset/train/california_train_2.csv', '/opt/ml/input/data/dataset/train/california_train_5.csv', '/opt/ml/input/data/dataset/train/california_train_4.csv', '/opt/ml/input/data/dataset/train/california_train_1.csv', '/opt/ml/input/data/dataset/train/california_train_3.csv']
Found validation files: ['/opt/ml/input/data/dataset/validation/california_validation_2.csv', '/opt/ml/input/data/dataset/validation/california_validation_1.csv', '/opt/ml/input/data/dataset/validation/california_validation_3.csv']

Aloja tu modelo en SageMaker

Después de entrenar su modelo de ML, puede implementarlo con SageMaker. Para implementar un punto final persistente en tiempo real que hace una predicción a la vez, usamos Servicios de alojamiento en tiempo real de SageMaker.

from sagemaker.serializers import CSVSerializer

predictor = estimator.deploy(1, "ml.t2.medium", serializer=CSVSerializer())

Primero, obtenemos el último conjunto de datos de prueba localmente en el cuaderno de desarrollo en Studio. Para este fin, podemos utilizar dvc.api.read() para cargar los datos sin procesar que el trabajo de procesamiento de SageMaker almacenó en Amazon S3.

import io
import dvc.api

raw = dvc.api.read(
    "dataset/test/california_test.csv",
    repo=dvc_repo_url,
    rev=dvc_branch
)

Luego preparamos los datos usando Pandas, cargamos un archivo CSV de prueba y llamamos predictor.predict para invocar el punto final de SageMaker creado anteriormente, con datos y obtener predicciones.

test = pd.read_csv(io.StringIO(raw), sep=",", header=None)
X_test = test.iloc[:, 1:].values
y_test = test.iloc[:, 0:1].values

predicted = predictor.predict(X_test)
for i in range(len(predicted)-1):
    print(f"predicted: {predicted[i]}, actual: {y_test[i][0]}")

Eliminar el punto final

Debe eliminar los puntos finales cuando ya no estén en uso, ya que se facturan por el tiempo de implementación (para obtener más información, consulte Precios de Amazon SageMaker). Asegúrese de eliminar el punto final para evitar costos inesperados.

predictor.delete_endpoint()

Limpiar

Antes de eliminar todos los recursos que creó, asegúrese de eliminar todas las aplicaciones de la data-scientist-dvc usuario, incluidas todas las aplicaciones KernelGateway, así como la aplicación predeterminada JupiterServer.

Luego, puede destruir la pila de CDK de AWS ejecutando el siguiente comando:

cdk destroy

Si usó un dominio existente, también ejecute los siguientes comandos:

# inject your DOMAIN_ID into the configuration file
sed -i 's/<your-sagemaker-studio-domain-id>/'"$DOMAIN_ID"'/' ../update-domain-no-custom-images.json
# update the sagemaker studio domain
aws --region ${REGION} sagemaker update-domain --cli-input-json file://../update-domain-no-custom-images.json

Conclusión

En esta publicación, analizó un ejemplo de cómo realizar un seguimiento de sus experimentos en código, datos, artefactos y métricas mediante el uso de SageMaker Experiments y los trabajos de procesamiento y capacitación de SageMaker junto con DVC. Creamos una imagen de Docker que contenía DVC, que se requería para Studio como cuaderno de desarrollo, y mostramos cómo puede usar trabajos de procesamiento y capacitación con DVC. Preparamos dos versiones de los datos y usamos DVC para administrarlos con Git. Luego usó Experimentos de SageMaker para realizar un seguimiento del procesamiento y el entrenamiento con las dos versiones de los datos para tener una vista unificada de parámetros, artefactos y métricas en un solo panel de vidrio. Finalmente, implementó el modelo en un punto final de SageMaker y utilizó un conjunto de datos de prueba de la segunda versión del conjunto de datos para invocar el punto final de SageMaker y obtener predicciones.

Como siguiente paso, puede ampliar el cuaderno existente e introducir su propia estrategia de ingeniería de funciones y usar DVC y SageMaker para ejecutar sus experimentos. ¡Vamos a construir!

Para leer más, consulte los siguientes recursos:

Acerca de los autores

paolo di francesco es arquitecto de soluciones en AWS. Tiene experiencia en telecomunicaciones e ingeniería de software. Le apasiona el aprendizaje automático y actualmente se está enfocando en usar su experiencia para ayudar a los clientes a alcanzar sus objetivos en AWS, en particular en discusiones sobre MLOps. Fuera del trabajo, le gusta jugar al fútbol y leer.

Eitan Sela es un arquitecto de soluciones especializado en aprendizaje automático con Amazon Web Services. Trabaja con los clientes de AWS para brindar orientación y asistencia técnica, ayudándolos a crear y operar soluciones de aprendizaje automático en AWS. En su tiempo libre, a Eitan le gusta hacer jogging y leer los últimos artículos sobre aprendizaje automático.