Adaptación del contenedor de entrenamiento propio - Amazon SageMaker
Paso 1: Crear una instancia de cuadernoPaso 2: Crear y cargar scripts de entrenamientoPaso 3: Compilar el contenedorPaso 4: Probar el contenedorPaso 5: Insertar el contenedor en Amazon ECRPaso 6: Eliminar recursosBlogs y casos prácticos

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.

Adaptación del contenedor de entrenamiento propio

Para ejecutar tu propio modelo de entrenamiento, crea un contenedor de Docker con el Amazon SageMaker Training Toolkit a través de una instancia de Amazon SageMaker Notebook.

Paso 1: Crea una instancia de bloc de notas SageMaker

  1. Abre la SageMaker consola de Amazon en https://console.aws.amazon.com/sagemaker/.

  2. En el panel de navegación, elija Notebook Cuaderno), seleccione Notebook instances (Instancias de cuaderno) y, a continuación, seleccione Create notebook instance (Crear instancia de cuaderno).

  3. En la página Crear instancia de bloc de notas, proporcione la siguiente información:

    1. En Notebook instance name (Nombre de instancia del bloc de notas), escriba RunScriptNotebookInstance.

    2. En Tipo de instancia de bloc de notas, elija ml.t2.medium.

    3. En la sección Permissions and encryption (Permisos y cifrado), haga lo siguiente:

      1. En Rol de IAM, elija Crear un nuevo rol. Se abre una nueva ventana.

      2. En la página Create an IAM role (Crear un rol de IAM), elija Buckets de S3 específicos, especifique un bucket de Amazon S3 denominado sagemaker-run-script y, a continuación, elija Create role (Crear rol).

        SageMaker crea un rol de IAM denominadoAmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS. Por ejemplo, AmazonSageMaker-ExecutionRole-20190429T110788. Tenga en cuenta que la convención de nomenclatura de rol de ejecución utiliza la fecha y la hora en que se creó el rol, separadas por una T.

    4. En Root Access (Acceso raíz), elija Enable (Habilitar).

    5. Elija Crear instancia de bloc de notas.

  4. En la página Notebook instances (Instancias de cuaderno), Status (Estado) es Pemnding (Pendiente). Amazon puede tardar unos minutos en SageMaker lanzar una instancia de procesamiento de aprendizaje automático (en este caso, lanza una instancia de notebook) y adjuntarle un volumen de almacenamiento de aprendizaje automático. La instancia de cuaderno cuenta con un servidor de cuaderno de Jupyter configurado previamente y un conjunto de bibliotecas de Anaconda. Para obtener más información, consulte CreateNotebookInstance.

  5. Haga clic en el Name (Nombre) del cuaderno que acaba de crear. Se abre una nueva página.

  6. En la sección Permissions and encryption (Permisos y cifrado), copie el número de ARN del rol de IAM y péguelo en un archivo de cuaderno para guardarlo temporalmente. Este número ARN del rol de IAM se utiliza más adelante para configurar un estimador de entrenamiento local en la instancia del cuaderno. El número de ARN de rol de IAM tiene el siguiente aspecto: 'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'.

  7. Cuando el estado de la instancia del bloc de notas cambie a InService, seleccione Abrir JupyterLab.

Paso 2: Crear y cargar scripts de entrenamiento de Dockerfile y Python

  1. Cuando JupyterLab se abra, cree una nueva carpeta en el directorio principal de su JupyterLab. En la esquina superior izquierda, elija el icono de nueva carpeta y, a continuación, escriba el nombre de la carpeta docker_test_folder.

  2. Cree un archivo de texto Dockerfile en el directorio docker_test_folder.

    1. Seleccione el icono del nuevo lanzador (+) en la esquina superior izquierda.

    2. En el panel derecho, en la sección Other (Otro), seleccione Text file (Archivo de texto).

    3. Pegue el siguiente código de ejemplo Dockerfile en el archivo de texto. 

      #Download an open source TensorFlow Docker image
FROM tensorflow/tensorflow:latest-gpu-jupyter

# Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker and the Python SDK.
RUN pip3 install sagemaker-training

# Copies the training code inside the container
COPY train.py /opt/ml/code/train.py

# Defines train.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py

      El script Dockerfile realiza las siguientes tareas:

      • FROM tensorflow/tensorflow:latest-gpu-jupyter— Descarga la última imagen base de TensorFlow Docker. Puede sustituirla por cualquier imagen base de Docker que desee utilizar para crear contenedores, así como por imágenes base de contenedores AWS prediseñadas.

      • RUN pip install sagemaker-training— Instala un kit de herramientas de SageMaker formación que contiene la funcionalidad común necesaria para crear un contenedor compatible con. SageMaker

      • COPY train.py /opt/ml/code/train.py— Copia el script en la ubicación prevista dentro del contenedor. SageMaker El script debe estar ubicado en esta carpeta.

      • ENV SAGEMAKER_PROGRAM train.py— Toma el script de entrenamiento train.py como script de punto de entrada copiado en la carpeta /opt/ml/code del contenedor. Esta es la única variable de entorno que debe especificar cuando crea su propio contenedor.

    4. En la navegación del directorio izquierdo, el nombre del archivo de texto se establece automáticamente como untitled.txt. Para cambiar el nombre del archivo, haga clic con el botón derecho en el archivo, seleccione Rename (Cambiar nombre), cámbiele el nombre a Dockerfile sin la extensión .txt y, a continuación, pulse Ctrl+s o Command+s para guardar el archivo.

  3. Cargue un script de entrenamiento train.py en la docker_test_folder. Para este ejercicio, puede usar el siguiente script de ejemplo para crear un modelo que lea dígitos manuscritos entrenados en el conjunto de datos MNIST.

    import tensorflow as tf
import os

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

model.fit(x_train, y_train, epochs=1)
model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"

model.evaluate(x_test, y_test)
tf.saved_model.save(model, model_save_dir)

Paso 3: Compilar el contenedor

  1. En el directorio JupyterLab principal, abre un cuaderno de Jupyter. Para abrir un cuaderno nuevo, seleccione el icono de nuevo lanzamiento y, a continuación, seleccione la última versión de conda_tensorflow2 en la sección Notebook (Cuaderno).

  2. Ejecute el siguiente comando en la primera celda del cuaderno para cambiar al directorio docker_test_folder:

    cd ~/SageMaker/docker_test_folder

    Esto devuelve su directorio actual como se indica a continuación: 

    ! pwd

    output: /home/ec2-user/SageMaker/docker_test_folder

  3. Para crear el contenedor de Docker, ejecute el siguiente comando de compilación de Docker, incluyendo el espacio seguido del punto final:

    ! docker build -t tf-custom-container-test .

    El comando de compilación de Docker debe ejecutarse desde el directorio creado, en este caso docker_test_folder.

    nota

    Si aparece el siguiente mensaje de error que indica que Docker no puede encontrar el Dockerfile, asegúrese de que el Dockerfile tenga el nombre correcto y se haya guardado en el directorio.

    unable to prepare context: unable to evaluate symlinks in Dockerfile path: 
lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory

    Recuerde que docker busca un archivo llamado específicamente Dockerfile sin ninguna extensión en el directorio actual. Si lo nombró de otra manera, puede pasar el nombre de archivo manualmente con la marca -f. Por ejemplo, si asignó el nombre Dockerfile-text.txt a su Dockerfile, ejecute el siguiente comando:

    ! docker build -t tf-custom-container-test -f Dockerfile-text.txt .

Paso 4: Probar el contenedor

  1. Para probar el contenedor localmente en la instancia de cuaderno, abra un cuaderno de Jupyter. Seleccione el icono de nuevo lanzamiento y, a continuación, seleccione la última versión de conda_tensorflow2 en la sección Notebook (Cuaderno).

  2. Pegue el siguiente script de ejemplo en la celda de código del cuaderno para configurar un SageMaker estimador.

    import sagemaker
from sagemaker.estimator import Estimator

estimator = Estimator(image_uri='tf-custom-container-test',
                      role=sagemaker.get_execution_role(),
                      instance_count=1,
                      instance_type='local')

estimator.fit()

    En el ejemplo de código anterior, sagemaker.get_execution_role() se especifica el role argumento para recuperar automáticamente el rol configurado para la SageMaker sesión. También puede sustituirlo por el valor de cadena del número de ARN del rol de IAM que utilizó al configurar la instancia de cuaderno. El ARN debería tener el aspecto siguiente: 'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'.

  3. Ejecute la celda de código. Esta prueba devuelve la configuración del entorno de capacitación, los valores utilizados en las variables de entorno, el origen de los datos y la pérdida y precisión obtenidas durante la capacitación.

Paso 5: Insertar el contenedor en Amazon Elastic Container Registry (Amazon ECR)

  1. Después de ejecutar correctamente la prueba de modo local, puede insertar el contenedor de Docker en Amazon ECR para utilizarlo para ejecutar trabajos de entrenamiento. Si desea utilizar un registro privado de Docker en lugar de Amazon ECR, consulte Insertar un contenedor de entrenamiento en un registro privado.

    Puede ejecutar manualmente comandos de Git como los siguientes en una celda del cuaderno.

    %%sh

# Specify an algorithm name
algorithm_name=tf-custom-container-test

account=$(aws sts get-caller-identity --query Account --output text)

# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}

fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"

# If the repository doesn't exist in ECR, create it.

aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi

# Get the login command from ECR and execute it directly

aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}

# Build the docker image locally with the image name and then push it to ECR
# with the full name.

docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}

docker push ${fullname}
    nota

    Este script de intérprete de comandos bash puede provocar un problema de permisos similar al siguiente mensaje de error:

    "denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"

    Si se produce este error, debe adjuntar la ContainerRegistryFullAccess política de AmazonEC2 a su función de IAM. Vaya a la consola de IAM, seleccione Roles en el panel de navegación izquierdo y busque el IAMrole usado para la instancia de cuaderno. En la pestaña Permisos, pulse el botón Adjuntar políticas y busque la política de AmazonEC2. ContainerRegistryFullAccess marque la casilla de verificación de la política y, a continuación, elija Add permissions (Añadir permisos) para finalizar.

  2. Ejecute el siguiente código en una celda de un cuaderno de Studio para llamar a la imagen de Amazon ECR de su contenedor de entrenamiento.

    import boto3

account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'

region = boto3.session.Session().region_name

uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
    uri_suffix = 'amazonaws.com.cn'

byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)

byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest

  3. Utilice lo ecr_image obtenido en el paso anterior para configurar un objeto SageMaker estimador. El siguiente ejemplo de código configura un SageMaker estimador con byoc_image_uri e inicia un trabajo de formación en una instancia de Amazon EC2.

    SageMaker Python SDK v1
    import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator

estimator = Estimator(image_uri=byoc_image_uri,
                      role=get_execution_role(),
                      base_job_name='tf-custom-container-test-job',
                      instance_count=1,
                      instance_type='ml.g4dn.xlarge')

#train your model
estimator.fit()
    SageMaker Python SDK v2
    import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator

estimator = Estimator(image_uri=byoc_image_uri,
                      role=get_execution_role(),
                      base_job_name='tf-custom-container-test-job',
                      instance_count=1,
                      instance_type='ml.g4dn.xlarge')

#train your model
estimator.fit()

  4. Si desea implementar el modelo con su propio contenedor, consulte Adaptación del contenedor de inferencias propio. También puede usar un contenedor AWS marco que pueda implementar un modelo. TensorFlow Para implementar el modelo de ejemplo para leer dígitos escritos a mano, introduzca el siguiente script de ejemplo en el mismo cuaderno usado para entrenar el modelo en el subpaso anterior para obtener los URI (identificadores universales de recursos) de imagen necesarios para la implementación e implemente el modelo.

    import boto3
import sagemaker

#obtain image uris
from sagemaker import image_uris
container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
                    image_scope='inference',instance_type='ml.g4dn.xlarge')

#create the model entity, endpoint configuration and endpoint
predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)

    Pruebe el modelo con un ejemplo de dígito manuscrito del conjunto de datos MNIST mediante el siguiente ejemplo de código.

    #Retrieve an example test dataset to test
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist

# Load the MNIST dataset and split it into training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Select a random example from the training set
example_index = np.random.randint(0, x_train.shape[0])
example_image = x_train[example_index]
example_label = y_train[example_index]

# Print the label and show the image
print(f"Label: {example_label}")
plt.imshow(example_image, cmap='gray')
plt.show()

    Convierta el dígito manuscrito de la prueba en una forma que TensorFlow pueda asimilar y hacer una predicción de prueba.

    from sagemaker.serializers import JSONSerializer
data = {"instances": example_image.tolist()}
predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
predictor.predict(data) #make the prediction

Para ver un ejemplo completo que muestra cómo probar un contenedor personalizado localmente y subirlo a una imagen de Amazon ECR, consulte el cuaderno de ejemplo Building Your Own TensorFlow Container.

sugerencia

Para perfilar y depurar los trabajos de formación a fin de supervisar los problemas de uso del sistema (como los cuellos de botella de la CPU y la infrautilización de la GPU) e identificar los problemas de formación (como el sobreajuste, el sobreentrenamiento, la explosión de los tensores y la desaparición de los gradientes), utilice Amazon Debugger. SageMaker Para obtener más información, consulte Usa Debugger con contenedores de entrenamiento personalizados.

Paso 6: Eliminar recursos

Para limpiar los recursos una vez que haya terminado con el ejemplo de inicio

  1. Abra la SageMaker consola, elija la instancia del bloc de notas, elija Actions y elija Stop. RunScriptNotebookInstance Puede que transcurran unos minutos hasta que la instancia se detenga.

  2. Cuando State (Estado) de la instancia cambie a Stopped (Detenida), elija Actions (Acciones), elija Delete (Eliminar) y, a continuación, elija Delete (Eliminar) en el cuadro de diálogo. Puede que transcurran unos minutos hasta que la instancia se elimine. La instancia del cuaderno desaparece de la tabla cuando se elimina.

  3. Abra la consola de Amazon S3 y elimine el bucket que creó para almacenar los artefactos del modelo y los conjuntos de datos de entrenamiento.

  4. Abra la consola de IAM y elimine el rol de IAM. Si ha creado políticas de permisos, puede eliminarlas también.

    nota

    El contenedor de Docker se cierra automáticamente después de que se haya ejecutado. No es necesario eliminarlo.

Blogs y casos prácticos

En los siguientes blogs se analizan casos prácticos sobre el uso de contenedores de formación personalizados en Amazon SageMaker.