Adaptación del contenedor de entrenamiento propio

1. Abra la consola de Amazon SageMaker AI 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 AI crea un rol de IAM denominado AmazonSageMaker-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 SageMaker AI puede tardar unos minutos en lanzar una instancia de computación de machine learning, en este caso, una instancia de cuaderno, y asociarle un volumen de almacenamiento de machine learning. 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 Crear una instancia de cuaderno.

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 cuaderno cambie a InService, seleccione Open JupyterLab (Abrir JupyterLab).

1. Cuando se abra JupyterLab, 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 AI 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 imagen base más reciente de Docker de TensorFlow. Puede sustituirla por cualquier imagen base de Docker que desee utilizar para crear contenedores, así como por imágenes base de contenedores precompilados de AWS.

      • RUN pip install sagemaker-training: instala SageMaker AI Training Toolkit, que contiene la funcionalidad común necesaria para crear un contenedor compatible con SageMaker AI.

      • COPY train.py /opt/ml/code/train.py: copia el script en la ubicación dentro del contenedor que espera SageMaker AI. 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)

1. En el directorio principal de JupyterLab, abra 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 .

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 script de ejemplo siguiente en la celda de código de cuaderno para configurar un estimador de SageMaker AI.

   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 en el argumento role para recuperar automáticamente el rol configurado para la sesión de SageMaker AI. 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.

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 asociar la política AmazonEC2ContainerRegistryFullAccess a su rol 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 Permission (Permiso), pulse el botón Attach policies (Asociar políticas) y busque la política AmazonEC2ContainerRegistryFullAccess. 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 la ecr_image recuperada en el paso anterior para configurar un objeto de estimador de SageMaker AI. El siguiente ejemplo de código configura un estimador de SageMaker AI con el byoc_image_uri e inicia un trabajo de entrenamiento 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 puedes usar un contenedor de marco AWS que pueda implementar un modelo de 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 escrito a mano de la prueba en un formato 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 limpiar los recursos una vez que haya terminado con el ejemplo de inicio

1. Abra la consola de SageMaker AI, seleccione la instancia de cuaderno RunScriptNotebookInstance, elija Acciones y elija Detener. 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.