Requisitos previos

SageMaker Neo es una función que te permite entrenar modelos de aprendizaje automático una vez y ejecutarlos en cualquier lugar de la nube y en la periferia. Antes de compilar y optimizar los modelos con Neo, debe configurar algunos requisitos previos. Debe instalar las bibliotecas de Python necesarias, configurar sus AWS credenciales, crear un rol de IAM con los permisos necesarios y configurar un bucket de S3 para almacenar los artefactos del modelo. También debe tener preparado un modelo de machine learning entrenado. Los pasos siguientes le guiarán a través de la configuración:

Instalación de Boto3

Si ejecuta estos comandos en su dispositivo periférico, debe instalar AWS SDK para Python (Boto3). En un entorno Python (preferiblemente un entorno virtual), ejecute lo siguiente localmente en el terminal de su dispositivo periférico o en una instancia de cuaderno de Jupyter:
Terminal
```
pip install boto3
```
Jupyter Notebook
```
!pip install boto3
```
Configure las credenciales AWS

Debe configurar las credenciales de Amazon Web Services en su dispositivo para ejecutar SDK for Python (Boto3). De forma predeterminada, las AWS credenciales deben almacenarse en el archivo ~/.aws/credentials del dispositivo perimetral. En el archivo de credenciales, debe ver dos variables de entorno: aws_access_key_id y aws_secret_access_key.

En su terminal, ejecute:
```
$ more ~/.aws/credentials

[default]
aws_access_key_id = YOUR_ACCESS_KEY
aws_secret_access_key = YOUR_SECRET_KEY
```
La Guía de referencia general AWS contiene instrucciones sobre cómo obtener las aws_access_key_id y aws_secret_access_key necesarias. Para obtener más información sobre cómo configurar las credenciales en su dispositivo, consulte la documentación de Boto3.
Configure un rol de IAM y asocie políticas.

Neo necesita acceder al URI del bucket de S3. Cree un rol de IAM que pueda ejecutar SageMaker IA y que tenga permiso para acceder al URI de S3. Puede crear un rol de IAM mediante el SDK para Python (Boto3), la consola o AWS CLI. El siguiente ejemplo ilustra cómo crear un rol de IAM mediante SDK for Python (Boto3):
```
import boto3

AWS_REGION = 'aws-region'

# Create an IAM client to interact with IAM
iam_client = boto3.client('iam', region_name=AWS_REGION)
role_name = 'role-name'
```
Para obtener más información sobre cómo crear un rol de IAM con la consola o mediante la AWS API AWS CLI, consulte Crear un usuario de IAM en su cuenta. AWS

Cree un diccionario que describa la política de IAM que va a asociar. Esta política se utiliza para crear un nuevo rol de IAM.
```
policy = {
    'Statement': [
        {
            'Action': 'sts:AssumeRole',
            'Effect': 'Allow',
            'Principal': {'Service': 'sagemaker.amazonaws.com'},
        }],  
     'Version': '2012-10-17'
}
```
Cree un nuevo rol de IAM con la política que definió anteriormente:
```
import json 

new_role = iam_client.create_role(
    AssumeRolePolicyDocument=json.dumps(policy),
    Path='/',
    RoleName=role_name
)
```
Necesitará saber cuál es su nombre de recurso de Amazon (ARN) cuando cree un trabajo de compilación en un paso posterior, así que guárdelo también en una variable.
```
role_arn = new_role['Role']['Arn']
```
Ahora que ha creado un nuevo rol, adjunte los permisos que necesita para interactuar con Amazon SageMaker AI y Amazon S3:
```
iam_client.attach_role_policy(
    RoleName=role_name,
    PolicyArn='arn:aws:iam::aws:policy/AmazonSageMakerFullAccess'
)

iam_client.attach_role_policy(
    RoleName=role_name,
    PolicyArn='arn:aws:iam::aws:policy/AmazonS3FullAccess'
);
```

Cree un bucket de Amazon S3 para almacenar los artefactos de sus modelos

SageMaker Neo accederá a los artefactos de sus modelos desde Amazon S3

Formación de un modelo de machine learning

Consulte Entrenar un modelo con Amazon SageMaker AI para obtener más información sobre cómo entrenar un modelo de aprendizaje automático con Amazon SageMaker AI. Si lo desea, puede cargar su modelo formado a nivel local directamente en un bucket de URI de Amazon S3.

nota
Asegúrese de que el modelo tenga el formato correcto en función del marco que haya utilizado. Consulte ¿Qué formas de datos de entrada espera SageMaker Neo?

Si aún no tiene un modelo, utilice el curl comando para obtener una copia local TensorFlow del coco_ssd_mobilenet modelo en el sitio web. El modelo que acaba de copiar es un modelo de detección de objetos formado a partir del conjunto de datos COCO. Escribe lo siguiente en su cuaderno de Jupyter:
```
model_zip_filename = './coco_ssd_mobilenet_v1_1.0.zip'
!curl http://storage.googleapis.com/download.tensorflow.org/models/tflite/coco_ssd_mobilenet_v1_1.0_quant_2018_06_29.zip \
    --output {model_zip_filename}
```
Tenga en cuenta que este ejemplo en particular se empaquetó en un archivo .zip. Descomprima este archivo y vuelva a empaquetarlo como un archivo tar comprimido (.tar.gz) antes de usarlo en pasos posteriores. Escribe lo siguiente en su cuaderno de Jupyter:
```
# Extract model from zip file
!unzip -u {model_zip_filename}

model_filename = 'detect.tflite'
model_name = model_filename.split('.')[0]

# Compress model into .tar.gz so SageMaker Neo can use it
model_tar = model_name + '.tar.gz'
!tar -czf {model_tar} {model_filename}
```
Cargue el modelo formado en un bucket de S3

Una vez que tenga un modelo de machine learning, guárdelo en un bucket de Amazon S3.
Boto3
```
# Upload model        
s3_client.upload_file(Filename=model_filename, Bucket=bucket, Key=model_filename)
```
CLI
Reemplace your-model-filename y amzn-s3-demo-bucket con el nombre de su bucket de S3.
```
aws s3 cp your-model-filename s3://amzn-s3-demo-bucket
```

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Configuración de Neo en dispositivos periféricos

Compile el modelo.

Requisitos previos

nota