Les progrès récents de l'apprentissage automatique (ML) ont produit des modèles de taille KiloByte pouvant être exécutés directement sur des appareils IoT. Cette approche évite une communication coûteuse entre les appareils IoT et le Cloud, permettant ainsi une analyse en temps réel et écoénergétique. Cependant, les modèles ML sont généralement exprimés en virgule flottante et les appareils IoT ne prennent généralement pas en charge la virgule flottante. Par conséquent, exécuter ces modèles sur des appareils IoT nécessite la simulation IEEE-754 virgule flottante en utilisant un logiciel, ce qui est inefficace.

Ces dernières années, nous avons constaté une augmentation des systèmes d'automatisation qui déploient des capteurs pour collecter des données et les analyser en utilisant des algorithmes d'apprentissage automatique (ML). Quelques exemples de tels systèmes comprennent une simple surveillance de la santé des personnes par des capteurs portables, surveillance à grande échelle des villes, etc.

Les systèmes typiques utilisent des capteurs (également appelés appareils IoT) qui ne collectent que des données et exécutent les algorithmes ML dans le Cloud.

Exécuter des classificateurs ML directement sur un appareil IoT possède trois avantages :

• Premièrement, cela améliore la sécurité et la confidentialité des données des utilisateurs en les conservant à la source plutôt que de les communiquer au Cloud.
• Deuxièmement, cela élimine la communication des données entre l'appareil IoT et le Cloud, réduisant ainsi la consommation d'énergie et surtout les problèmes potentiels de réseau.
• Troisièmement, exécuter les algorithmes sur l'appareil IoT réduit considérablement la latence de la prédiction, permettant une analyse en temps réel.

Malgré ces avantages, il existe deux défis majeurs pour exécuter des algorithmes de ML sur des appareils IoT :

• Premièrement, les appareils IoT ont des ressources de calcul et de mémoire limitées (quelques Ko). Par conséquent, ils ne peuvent pas exécuter des modèles ML typiques qui pèsent des Mo ou Go.
• Deuxièmement, ces appareils IoT n'ont pas de matériel capable de prendre en charge des opérations en virgule flottante. Or, la plupart des algorithmes ML utilisent ces opérations en virgule flottante.

Aws SageMaker Edge

L’objectif ici est de vous présenter le nouveau service proposé par AWS, le service Amazon SageMaker Edge Manager, une nouvelle fonctionnalité d'Amazon SageMaker qui facilite l'optimisation, la sécurisation, la surveillance et la maintenance des modèles d'apprentissage automatique sur une flotte d'appareils IOT “Edge Devices”.

C’est donc un service qui :

• va vous permettre de préparer des modèles personnalisés pour vos appareils IOT “on Edge”,
• comprend un environnement d'exécution pour exécuter efficacement l'inférence de ML sur les Edge Devices,
• permet à l'appareil d'envoyer des échantillons de données de chaque modèle en toute sécurité à SageMaker pour réétiquetage et recyclage.

Nous allons commencer par une introduction sur les différents composants de ce nouveau service, et puis par la suite une petite simulation sur son utilisation dans SageMaker.

Dans le service SageMaker Edge Manager, il y a deux principaux composants :

• SageMaker Edge Agent,
• SageMaker Edge Manager.

SageMaker Edge Agent

Situé sur les appareils IOT, cet agent permet de gérer les modèles du Machine Learning. Il communique principalement avec AWS pour le déploiement des modèles et avec votre application pour la gestion des modèles.

Vous pouvez donc intégrer cet agent à votre application pour que vous puissiez automatiquement charger/décharger des modèles en fonction de votre besoin prédictif.

Cela permet une variété de scénarios, tels que la libération de toutes les ressources pour un grand modèle chaque fois que nécessaire, ou l'utilisation d'une collection de modèles plus petits qui cohabitent en mémoire.

SageMaker Edge Manager

Amazon SageMaker Edge Manager permet aux développeurs du ML Edge d'utiliser facilement les mêmes outils familiers dans le Cloud ou sur des appareils Edge. Cela réduit le temps et les efforts nécessaires pour mettre les modèles en production, tout en surveillant et en améliorant en permanence la qualité des modèles sur l'ensemble de votre parc d'appareils.

À partir d'un modèle que vous avez entraîné ou importé dans Amazon SageMaker, SageMaker Edge Manager l'optimise d'abord pour votre plate-forme matérielle à l'aide d'Amazon SageMaker Neo. Neo convertit les modèles en un format commun efficace qui est exécuté sur l'appareil par un runtime à faible encombrement. Neo prend actuellement en charge les appareils basés sur des puces fabriquées par Ambarella, ARM, Intel, NVIDIA, NXP, Qualcomm, TI et Xilinx.

Ensuite, SageMaker Edge Manager package le modèle et le stocke dans Amazon Simple Storage Service (S3), d’où il peut être déployé sur vos appareils. En effet, vous pouvez déployer plusieurs modèles, charger et prédire avec un runtime optimisé pour le matériel de votre choix.

Optimisation des modèles de ML pour une large gamme d'appareils

Amazon SageMaker Edge Manager optimise automatiquement les modèles de ML pour le déploiement sur une grande variété d’Edge Devices, y compris les appareils alimentés par des processeurs, des GPU et des accélérateurs de ML intégrés. SageMaker Edge Manager compile votre modèle entraîné en un exécutable qui découvre et applique des optimisations de performances spécifiques qui peuvent rendre votre modèle jusqu'à 25 fois plus rapide sur le matériel cible. SageMaker Edge Manager vous permet d'optimiser et de mettre en package des modèles entraînés à l'aide de différents frameworks tels que DarkNet, Keras, MXNet, PyTorch, TensorFlow, TensorFlow-Lite, ONNX et XGBoost pour l'inférence sur les machines Android, iOS, Linux et Windows.

Intégration facile avec les applications de l'appareil

Amazon SageMaker Edge Manager prend en charge gRPC, un appel de procédure à distance open source, qui vous permet d'intégrer SageMaker Edge Manager à vos applications de périphérie existantes via des API dans des langages de programmation courants, tels que Android Java, C # / .NET, Dart, Go, Java, Kotlin / JVM, Node.js, Objective-C, PHP, Python, Ruby et Web.

Surveillance continue du modèle

Amazon SageMaker Edge Manager collecte les données des Edge Devices et envoie un échantillon au Cloud où il est analysé et visualisé dans SageMaker. Si des baisses de qualité sont détectées, vous pouvez les repérer rapidement dans le tableau de bord et également configurer des alertes via Amazon CloudWatch. La baisse de la qualité du modèle, ou la dérive du modèle, peut être causée par des différences dans les données utilisées pour faire des prédictions par rapport aux données utilisées pour entraîner le modèle, ou par des changements dans le monde réel. Par exemple, un modèle de détection d'objets qui n'est pas entraîné sur des images dans des conditions de neige ne fonctionne pas bien lorsqu'il les rencontre dans le monde réel.

Tableau de bord

Amazon SageMaker Edge Manager fournit un tableau de bord afin que vous puissiez comprendre les performances des modèles exécutés sur chaque appareil de votre parc. Le tableau de bord vous aide à comprendre visuellement la santé globale de la flotte et à identifier les modèles problématiques via un tableau de bord dans la console. Lorsqu'un problème est identifié, vous pouvez collecter des données de modèle, renommer les données, réentraîner le modèle et le redéployer.

D’autres services sont en cours de finalisation, comme :

• Servir plusieurs modèles de façon concurrente dans un appareil,
• Automatiser tout le flux du début à la fin “Build, Train, Deploy”.

Simulation de l’utilisation d’AWS SageMaker Edge

Le but de la suite est de tester ce nouveau service en faisant une simulation d’un appareil IOT, en le créant à l’aide du Client Boto3 sur SageMaker.

Pour commencer il faut bien sûr avoir un rôle sur SageMaker qui permet l'accès à S3 et à l’EC2 (l’instance dans laquelle on va créer l’agent).

Voici les policies dont vous aurez besoin pour commencer :

• AmazonEC2FullAccess,
• AmazonEC2RoleforSSM,
• AmazonSSMManagedInstanceCore,
• AmazonSSMFullAccess,
• AWSIoTFullAccess.

Pour commencer il faut initialiser une session SageMaker et y assigner un bucket par défaut dans lequel vous pourrez mettre les données, les résultats, etc. Ensuite, il faut créer un sous dossier “iot” dans lequel on va mettre les données. Dans cet exemple, on va uploader une image sous format bmp.

Pour résumer, on a en ce moment un bucket S3 qui contient :

• Un dossier : compilation-output,
• Un dossier : “iot” qui contient pour le moment une image.

Voici l’image utilisée :

Création d’une instance

Il faut donc maintenant créer une instance EC2 qui remplace le Edge Agent Device pour exécuter le logiciel de l’agent.

ec2_client = boto3.client('ec2', region_name=region)

Et puis générer une paire de clés de l’instance afin qu’on puisse par la suite utiliser AWS Systems Manager pour envoyer les commandes à l’instance.

key_pair = str(ec2_key_pair['KeyMaterial'])
key_pair_file = open('ec2-key-pair.pem','w')
key_pair_file.write(key_pair)
key_pair_file.close()

Comme l’instance a besoin aussi de droits d'accès, la prochaine étape sera d'attacher les bonnes policies au rôle assigné à l’instance EC2. Voici la liste :

• AmazonS3FullAccess,
• AmazonSSMManagedInstanceCore,
• CloudWatchAgentAdminPolicy.

Il faut aussi remplacer le contenu de la policy “AmazonSageMaker-ExecutionPolicy”, liée au rôle de SageMaker par :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::<account>:role/<role-name>"
        }
    ]

On lance maintenant une instance :

ec2_profile_name = 'sagemaker-edge-demo'  # the name of the role created for EC2

ec2_instance = ec2_client.run_instances(
     ImageId=ami_map[region],
     MinCount=1,
     MaxCount=1,
     InstanceType='c5.large',
     KeyName='ec2-key-pair',
     IamInstanceProfile={
        'Name': ec2_profile_name}
)

Compilation du modèle

Comme discuté dans l’introduction, les modèles doivent être compilés à l’aide d’un autre service AWS. C’est AWS SageMaker Neo.

Pour tester un modèle on doit tester un modèle issu d’un framework supporté par AWS SageMaker Edge manager. Dans l’exemple, on va essayer un modèle du framework Darknet qu’on peut télécharger ici :

“https://github.com/pjreddie/darknet/blob/master/cfg/yolov3-tiny.cfg?raw=true”

“https://pjreddie.com/media/files/yolov3-tiny.weights”

Il s’agit d’un modèle de deep learning pour la détection d’objets. Une fois que les fichiers nécessaires sont téléchargés, on peut uploader le modèle dans S3 :

darknet_model_path = sess.upload_data('yolov3-tiny.tar.gz', bucket, folder)

Pour la compilation du modèle, il faut préciser le framework utilisé (Darknet dans l’exemple) et la forme des données (pour notre exemple c’est: {"data":[1,3,416,416]}). Et donc maintenant on peut compiler le modèle :

import time
darknet_compilation_job_name = 'Sagemaker-Edge-'+ str(time.time()).split('.')[0]
print('Compilation job for %s started' % darknet_compilation_job_name)

response = sagemaker_client.create_compilation_job(
        CompilationJobName=darknet_compilation_job_name,
        RoleArn=role,
        InputConfig={
            'S3Uri': darknet_model_path,
            'DataInputConfig': darknet_model_data_shape,
            'Framework': darknet_model_framework.upper()
        },
        OutputConfig={
            'S3OutputLocation': s3_compilation_output_location,
            'TargetDevice': target_device 
        },
        StoppingCondition={
            'MaxRuntimeInSeconds': 900
        }
    )

print(response)

# Poll every 30 sec
while True:
    response = sagemaker_client.describe_compilation_job(CompilationJobName=darknet_compilation_job_name)
    if response['CompilationJobStatus'] == 'COMPLETED':
        break
    elif response['CompilationJobStatus'] == 'FAILED':
        raise RuntimeError('Compilation failed')
    print('Compiling ...')
    time.sleep(30)
print('Done!')

Packaging du modèle

Maintenant que le modèle est déployé, on doit le packager avec SageMaker Edge manager. On commence donc par initialiser le nom du modèle, la version, et l’emplacement souhaité, et puis on utilise le constructeur create_edge_packaging_job pour créer un job de packaging :

darknet_packaging_job_name=darknet_compilation_job_name+"-packaging"
response = sagemaker_client.create_edge_packaging_job(
    RoleArn=role,
    OutputConfig={
        'S3OutputLocation': s3_compilation_output_location,
    },
    ModelName=darknet_packaged_model_name,
    ModelVersion=darknet_model_version,
    EdgePackagingJobName=darknet_packaging_job_name,
    CompilationJobName=darknet_compilation_job_name,
)

print(response)

# Poll every 30 sec
while True:
    job_status = sagemaker_client.describe_edge_packaging_job(EdgePackagingJobName=darknet_packaging_job_name)
    if job_status['EdgePackagingJobStatus'] == 'COMPLETED':
        break
    elif job_status['EdgePackagingJobStatus'] == 'FAILED':
        raise RuntimeError('Edge Packaging failed')
    print('Packaging ...')
    time.sleep(30)
print('Done!')

Création d’un AWS IoT

Le Edge manager, utilise le core d’AWS IoT pour valider l’appareil de façon à faciliter les appels aux endpoints de SageMaker Edge manager dans AWS.

On va donc utiliser boto3 pour créer un IoT :

iot_client = boto3.client('iot', region_name=region)
iot_thing_name = 'sagemaker-edge-thing-demo'
iot_thing_type = 'SagemakerEdgeDemo'
iot_client.create_thing_type(
    thingTypeName=iot_thing_type
)

iot_client.create_thing(
    thingName=iot_thing_name,
    thingTypeName=iot_thing_type
)

Création d’un Device Fleet

Pour la configuration, il faut attacher ces policies :

• AmazonSageMakerEdgeDeviceFleetPolicy,
• AmazonSageMakerFullAccess,
• AmazonS3FullAccess,
• AWSIoTFullAccess.

Et ajouter ce statement :

{
  "Version": "2012-10-17",
  "Statement": [
      {
        "Effect": "Allow",
        "Principal": {"Service": "credentials.iot.amazonaws.com"},
        "Action": "sts:AssumeRole"
      },
      {
        "Effect": "Allow",
        "Principal": {"Service": "sagemaker.amazonaws.com"},
        "Action": "sts:AssumeRole"
      }
  ]
}

Après on crée le Device Fleet :

device_fleet_name ="demo-device-fleet"

sagemaker_client.create_device_fleet(
    DeviceFleetName=device_fleet_name,
    RoleArn='your-role-arn', # arn:aws:iam::<account>:role/<role name>
    OutputConfig={
        'S3OutputLocation': s3_compilation_output_location
    }
)

Et on l’enregistre :

device_name = "sagemaker-edge-demo-device-012345678" # device name should be 36 charactors

sagemaker_client.register_devices(
    DeviceFleetName=device_fleet_name,
    Devices=[
        {          
            "DeviceName": device_name,
            "IotThingName": iot_thing_name,
            "Description": "this is a sample virtual device"
        }
    ]
)

La suite de l'enchaînement va être de :

• Créer un certificat client pour AWS IoT,
• Créer un SSM (Systems Manager) pour l’inférence,
• Mettre en place l’agent,
• Lancer l’agent,
• Charger le modèle,
• Lancer des prédictions sur le modèle,
• Capturer les données.

Créer et enregistrer un certificat client avec AWS IoT

On crée une clé privée, clé publique et des fichiers de certificat X.509, puis on enregistre et active le certificat avec AWS IoT :

iot_cert = iot_client.create_keys_and_certificate(
    setAsActive=True
)

Ensuite il est nécessaire d’enregistrer les fichiers et les uploader dans S3. Ces fichiers vont être utilisés pour donner les credentials au device pour ouvrir la communication avec les services d’AWS.

with open('./iot.pem.crt', 'w') as f:
    for line in iot_cert['certificatePem'].split('\n'):
        f.write(line)
        f.write('\n')

with open('./iot_key.pem.key', 'w') as f:
    for line in iot_cert['keyPair']['PrivateKey'].split('\n'):
        f.write(line)
        f.write('\n')

with open('./iot_key_pair.pem.key', 'w') as f:
    for line in iot_cert['keyPair']['PublicKey'].split('\n'):
        f.write(line)
        f.write('\n')

role_alias_name = 'SageMakerEdge-' + device_fleet_name

role_alias = iot_client.describe_role_alias(
    roleAlias=role_alias_name
)

Le code suivant permet d’avoir les credentials :

iot_endpoint = iot_client.describe_endpoint(
    endpointType='iot:CredentialProvider'
)

endpoint = "https://{}/role-aliases/{}/credentials".format(iot_endpoint['endpointAddress'], role_alias_name)

Maintenant on va uploader les fichiers d’Amazon Root CA dans S3.

!wget https://www.amazontrust.com/repository/AmazonRootCA1.pem

On va utiliser ces fichiers pour la mise en place de l’agent de SageMaker Edge Manager.

root_ca_path = sess.upload_data('AmazonRootCA1.pem', bucket, iot_folder)
device_cert_path = sess.upload_data('iot.pem.crt', bucket, iot_folder)
device_key_path = sess.upload_data('iot_key.pem.key', bucket, iot_folder)

Création d’un SSM

ssm_client = boto3.client('ssm', region_name=region)

Mise en place de l’agent

ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "#!/bin/bash",
            "mkdir /demo",
            "aws s3 cp s3://sagemaker-edge-release-store-us-west-2-linux-x64/Releases/" + version + "/" + version + ".tgz demo.tgz",
            "tar -xf demo.tgz -C /demo",
            "cd /demo/bin",
            "chmod +x sagemaker_edge_agent_binary",
            "chmod +x sagemaker_edge_agent_client_example"
        ]
    }
)

La prochaine étape consiste à télécharger les certificats IoT travaillés avant, la clé privée de l’instance EC2. Ainsi que le modèle et l’image de test dans l’instance EC2.

ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "#!/bin/bash",
            "cd /demo",
            "mkdir iot-credentials",
            "cd iot-credentials",
            "aws s3 cp " + root_ca_path + " .",  
            "aws s3 cp " + device_cert_path + " .",
            "aws s3 cp " + device_key_path + " .",
            "cd /demo",
            "aws s3 cp " + darknet_img_path + " .",
            "aws s3 cp " + darknet_model_data + " .",
            "mkdir darknet_model",
            "tar -xf " + darknet_model_package + " -C darknet_model",
            "aws s3 cp " + keras_img_path + " .",
            "aws s3 cp " + keras_model_data + " .",
            "mkdir keras_model",
            "tar -xf " + keras_model_package + " -C keras_model"
        ]
    }
)

Configuration de l’agent :

sagemaker_edge_config = {
    "sagemaker_edge_core_device_uuid": device_name,
    "sagemaker_edge_core_device_fleet_name": device_fleet_name,
    "sagemaker_edge_core_capture_data_buffer_size": 30,
    "sagemaker_edge_core_capture_data_batch_size": 10,
    "sagemaker_edge_core_capture_data_push_period_seconds": 4,
    "sagemaker_edge_core_folder_prefix": "demo_capture",
    "sagemaker_edge_core_region": region,
    "sagemaker_edge_core_root_certs_path": "/demo/certificates",
    "sagemaker_edge_provider_aws_ca_cert_file": "/demo/iot-credentials/AmazonRootCA1.pem",
    "sagemaker_edge_provider_aws_cert_file": "/demo/iot-credentials/iot.pem.crt",
    "sagemaker_edge_provider_aws_cert_pk_file": "/demo/iot-credentials/iot_key.pem.key",
    "sagemaker_edge_provider_aws_iot_cred_endpoint": endpoint,
    "sagemaker_edge_provider_provider": "Aws",
    "sagemaker_edge_provider_s3_bucket_name": bucket,
    "sagemaker_edge_core_capture_data_destination": "Cloud"
}

edge_config_file = open("sagemaker_edge_config.json", "w")
json.dump(sagemaker_edge_config, edge_config_file, indent = 6)
edge_config_file.close()

Afin de continuer et lancer l’agent après il faut télécharger le fichier de configuration de l’agent dans EC2 :

config_path = sess.upload_data('sagemaker_edge_config.json', bucket, iot_folder)
ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "#!/bin/bash",
            "aws s3 cp " + config_path + ' /demo'
        ]
    }
) 

On utilisant le fichier de configuration de l’étape d’avant on va lancer l’agent :

agent_out = ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "cd /demo",
            "rm -f /tmp/sagemaker_edge_agent_example.sock",
            "./bin/sagemaker_edge_agent_binary -a /tmp/sagemaker_edge_agent_example.sock -c sagemaker_edge_config.json" 
        ]
    }
)
ssm_client.get_command_invocation(
    CommandId=agent_out['Command']['CommandId'],
    InstanceId=instance_id,
)

Et puis on va charger le modèle avec le script suivant :

load_darknet_model_out = ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "cd /demo",
            "./bin/sagemaker_edge_agent_client_example LoadModel darknet_model demo-darknet"
        ]
    }
)

ssm_client.get_command_invocation(
    CommandId=load_darknet_model_out['Command']['CommandId'],
    InstanceId=instance_id,
)

Maintenant je vais vous montrer comment lancer des prédictions sur le modèle en utilisant l’image de test présentée dans la section “Compilation du modèle” :

darknet_predict_out = ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "cd /demo",
            "./bin/sagemaker_edge_agent_client_example Predict demo-darknet darknet.bmp data 416 416 3"
        ]
    }
)

ssm_client.get_command_invocation(
    CommandId=darknet_predict_out['Command']['CommandId'],
    InstanceId=instance_id,
)

Capturer les données

Et voilà comment vous pouvez capturer les données des inputs et des outputs de l’inférence dans le Cloud :

darknet_capture_out = ssm_client.send_command(
    InstanceIds=[instance_id],
    DocumentName="AWS-RunShellScript",
    OutputS3BucketName=bucket,
    OutputS3KeyPrefix=folder,
    Parameters={
        'commands':[
            "cd /demo",
            "./bin/sagemaker_edge_agent_client_example PredictAndCapture demo-darknet darknet.bmp data 416 416 3"
        ]
    }
)

ssm_client.get_command_invocation(
    CommandId=darknet_capture_out['Command']['CommandId'],
    InstanceId=instance_id,
)

Conclusion

Dans cet article, on vous a présenté ce nouveau service proposé par AWS lors de re:Invent 2020 : AWS SageMaker Edge Manager. Ce service permet de faciliter le déploiement, le monitoring et la gestion des modèles de prédiction du ML sur des Edge Devices. Les modèles on-device sont gérés par un Agent que vous pouvez installer sur votre application. Cela va vous permettre de charger et décharger des modèles, suivre les résultats, etc.

Ce nouveau service facilite l’intégration des modèles de prédiction, avec d’autres features à venir très intéressantes. Ainsi, vous pouvez entraîner vos modèles, gérer et monitorer vos modèles, déployer vos modèles sur des Ddge Devices tout en restant sur Amazon SageMaker.