Como soluciono um erro de algoritmo em meu trabalho de processamento do SageMaker AI?

Breve descrição

Quando você executa um trabalho de processamento do SageMaker AI, você pode receber a mensagem de erro “Failure reason AlgorithmError: , exit code: 1” pelos seguintes motivos:

• Há um problema de dependência do Python.
• Ocorre um erro runtime do Python e você recebe um código de saída diferente de zero.
• Você está usando um contêiner do Docker criado para uma arquitetura de CPU diferente.

Resolução

Observação: se você receber erros ao executar comandos da AWS Command Line Interface (AWS CLI), consulte Solução de problemas da AWS CLI. Além disso, verifique se você está usando a versão mais recente da AWS CLI.

Identifique a causa do erro

Para identificar a causa do erro, use o Amazon CloudWatch Logs para revisar o log de rastreamento de pilha. O log de rastreamento de pilha mostra o que causou a falha no código e quando a falha ocorreu no script de processamento.

Depois de identificar a causa do erro, execute manualmente o contêiner a partir de um terminal. Se você não tiver o docker instalado, use as instâncias do notebook SageMaker AI para executar o contêiner. Certifique-se de usar o tipo de instância apropriado.

Puxe o contêiner para seu ambiente local

Se você usa um contêiner pré-construído do SageMaker AI, como o Scikit-learn, faça login no registro e extraia o contêiner. Para fazer login, execute o comando get-login-password da AWS CLI:

aws ecr get-login-password --region $REGION | docker login -u AWS --password-stdin 683313688378.dkr.ecr.${REGION}.amazonaws.com

Observação: substitua a região pela sua região da AWS.

Para puxar o contêiner, execute o seguinte comando:

docker pull 683313688378.dkr.ecr.${REGION}.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3

Observação: se você usa os algoritmos do SageMaker AI, como o Random Cut Forest, não é possível transferir o contêiner para o seu ambiente local. Para esses contêineres, entre em contato com o AWS Support.

Crie um shell bash em seu contêiner

Para solucionar problemas com seu código, execute o contêiner em seu ambiente local. Crie uma pasta chamada código e, em seguida, adicione seu código à pasta. Monte o diretório que inclui sua pasta de código em seu contêiner como um volume. Em seguida, monte a saída do diretório no mesmo local mostrado no exemplo a seguir:

docker run \
    -v ./code:/opt/ml/processing/input/code \
    -v ./output:/opt/ml/processing/output \
    --entrypoint '/bin/bash' \
    683313688378.dkr.ecr.us-east-1.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3

O comando anterior cria um shell bash em seu contêiner. Na seção Solucionar problemas de erros do algoritmo, atualize seu código na pasta de código e use o shell bash para executar seu script de processamento.

Solucionar erros de algoritmo

Problema de dependência do Python

Se você não especificar uma versão do pacote Python, o pip instala o pacote mais recente que pode causar um erro de algoritmo. Para solucionar esse problema, identifique a versão do pacote e instale os pacotes no script de processamento.

Se você usar um contêiner pré-criado do SageMaker, encontre o repositório para o código-fonte. Recupere os pacotes e as versões do Python que você usa no contêiner. Ou execute o seguinte comando no shell bash para ver a lista completa de pacotes para um contêiner personalizado:

pip freeze | grep '==' > /opt/ml/processing/input/code/requirements.txt

Depois de identificar a versão do pacote, crie um arquivo requirements.txt no mesmo diretório do script processing.py. Em seguida, adicione os pacotes necessários ao arquivo requirements.txt.

Exemplo de arquivo requirements.txt que usa o repositório Scikit-learn do SageMaker AI:

# Scikit-learn 1.2-1 packages
boto3==1.28.57
botocore>=1.31.57,<1.32.0
cryptography
Flask==1.1.1
itsdangerous==2.0.1
gunicorn==20.0.4
model-archiver==1.0.3
multi-model-server==1.1.1
pandas==1.1.3
protobuf==3.20.2
psutil==5.7.2
python-dateutil==2.8.1
retrying==1.3.3
sagemaker-containers==2.8.6.post2
sagemaker-inference==1.2.0
sagemaker-training==4.8.0
scikit-learn==1.2.1
scipy==1.8.0
urllib3==1.26.17
six==1.15.0
jinja2==3.0.3
MarkupSafe==2.1.1
numpy==1.24.1
gevent==23.9.1
Werkzeug==2.0.3
setuptools
wheel
certifi

# Your packages and their versions
sagemaker==2.232.1
boto3==1.34.142
botocore>=1.34.142,<1.35.0

Para instalar os pacotes necessários, execute o comando pip em seu script processing.py:

import sys
import subprocess


def install(requirements: str) -> None:
    subprocess.check_call([sys.executable, "-q", "-m", "pip", "install", "-r", requirements])


def install_requirements() -> None:
    install("/opt/ml/processing/input/code/requirements.txt")


def main() -> None:
    import sagemaker
    import pandas
    example_code


if __name__ == "__main__":
    install_requirements()
    main()

Observação: substitua example_code pelo seu código. Certifique-se de que os pacotes existentes não sejam atualizados.

Para testar se você adicionou as versões corretas do pacote ao script processing.py, execute o seguinte comando no shell bash:

cd /opt/ml/processing/input/code
python3 process.py

Se o script falhar, continue atualizando as versões do pacote até que o script seja bem-sucedido.

Solucionar problemas de runtime do Python

Para solucionar um problema de runtime do Python, modifique seu código na pasta código para atualizar seu script processing.py. Para testar seu script processing.py, execute os seguintes comandos no shell bash:

cd /opt/ml/processing/input/code
python3 processing.py

Modifique seu código até resolver todos os problemas no log de rastreamento de pilha e receber o código de saída “0”.

Solucionar problemas de arquitetura de CPU

Você deve manter uma versão de contêiner criada para a CPU específica. Obtenha a imagem existente e crie um novo Dockerfile que inclua somente a imagem do contêiner (FROM IMAGE_URI). Em seguida, envie o contêiner para seu Amazon Elastic Container Registry (Amazon ECR) existente.

O exemplo a seguir pega uma imagem criada para x86_64 e a reconstrói para uma arquitetura ARM:

#!/usr/bin/env bash
algorithm_name=ALGORITHM_NAME
sagemaker_account=SAGEMAKER_ACCOUNT_NUMBER
your_account=$(aws sts get-caller-identity --query Account --output text)
region=$(aws configure get region)
fullname="${your_account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:graviton-latest"

aws ecr get-login-password --region ${region} | docker login -u AWS --password-stdin ${sagemaker_account}.dkr.ecr.${region}.amazonaws.com
docker build -t ${algorithm_name} --platform=linux/arm64 .
docker tag ${algorithm_name} ${fullname}


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


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

Observação: substitua ALGORITHM_NAME e SAGEMAKER_ACCOUNT_NUMBER por seus valores.

Teste seu trabalho de processamento

Para testar sua tarefa de processamento atualizada, execute o seguinte comando:

import boto3
import sagemaker
from sagemaker import get_execution_role
from sagemaker.sklearn.processing import SKLearnProcessor
from sagemaker.processing import ProcessingInput, ProcessingOutput


role = get_execution_role()

local_mode = True

if local_mode:
    sklearn_processor = SKLearnProcessor(
        framework_version="1.2-1", role=role, instance_type="local", instance_count=1
    )
else:
    sklearn_processor = SKLearnProcessor(
        framework_version="1.2-1", role=role, instance_type="ml.m5.xlarge", instance_count=1
    )

sklearn_processor.run(code='code/processing.py',
                      inputs=[ProcessingInput(
                          source='./code/',
                          destination='/opt/ml/processing/input/code/')],
                      outputs=[ProcessingOutput(
                          output_name='output',
                          source='/opt/ml/processing/output/')]
                     )

Observação: substitua instance_type por local ou local-gpu para executar o trabalho como um teste.