Adaptación del contenedor de entrenamiento propio

1. Abre la consola 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. Para IAMel rol, elija Crear un nuevo rol. Se abre una nueva ventana.

      2. En la página Crear un IAM rol, elija buckets S3 específicos, especifique un nombre para un bucket de Amazon S3 ysagemaker-run-script, a continuación, elija Crear rol.

         SageMaker La IA crea un IAM rol 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 SageMaker AI puede tardar unos minutos en 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 Permisos y cifrado, copie el ARN número de IAM rol y péguelo en un archivo de bloc de notas para guardarlo temporalmente. Este ARN número de IAM función se utilizará más adelante para configurar un estimador de formación local en la instancia del bloc de notas. El ARN número de IAM rol 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, elija Abrir JupyterLab.

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 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 ú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 formación en SageMaker IA que contiene la funcionalidad común necesaria para crear un contenedor compatible con la IA. SageMaker

      • COPY train.py /opt/ml/code/train.py— Copia el script en la ubicación prevista por SageMaker la IA dentro del contenedor. 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 los dígitos manuscritos entrenados en el MNISTconjunto de datos.

   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 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 .

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 AI Estimator.

   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 sesión de SageMaker IA. También puede sustituirlo por el valor de cadena del ARN número de IAM rol que utilizó al configurar la instancia del bloc de notas. ARNDebería tener el siguiente aspecto:'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, puedes enviar el contenedor de Docker a Amazon ECR y usarlo para ejecutar tareas de formación. Si quieres usar un registro de Docker privado en lugar de AmazonECR, consulta Cómo transferir tu contenedor de formación a 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, tendrás que adjuntar la EC2ContainerRegistryFullAccess política de Amazon a tu IAM función. Ve a la IAMconsola, selecciona Funciones en el panel de navegación izquierdo y busca las IAMrole que usaste para la instancia de Notebook. En la pestaña Permiso, selecciona el botón Adjuntar políticas y busca la EC2ContainerRegistryFullAccess política de Amazon. marque la casilla de verificación de la política y, a continuación, elija Add permissions (Añadir permisos) para finalizar.

2. Ejecuta el siguiente código en una celda de un bloc de notas de Studio para llamar a la ECR imagen de Amazon de tu 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. Usa lo ecr_image obtenido en el paso anterior para configurar un objeto estimador de SageMaker IA. El siguiente ejemplo de código configura un estimador de SageMaker IA 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 puedes 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 bloc de notas que utilizó para entrenar el modelo en el subpaso anterior para obtener la imagen URIs (identificadores de recursos universales) necesaria para el despliegue e implementar 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 dígito manuscrito de muestra del MNIST conjunto de datos 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()

   Convierte el dígito manuscrito de 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 limpiar los recursos una vez que haya terminado con el ejemplo de inicio

1. Abra la consola de SageMaker IA, 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. Abre la IAMconsola y elimina el IAM rol. 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.