Déployer des modèles Amazon SageMaker Autopilot sur des points de terminaison d'inférence sans serveur

Pilote automatique Amazon SageMaker construit, forme et ajuste automatiquement les meilleurs modèles d'apprentissage automatique (ML) en fonction de vos données, tout en vous permettant de conserver un contrôle et une visibilité totale. Le pilote automatique peut également déployer automatiquement des modèles entraînés sur des points de terminaison d'inférence en temps réel.

Si vous avez des charges de travail avec des modèles de trafic irréguliers ou imprévisibles qui peuvent tolérer des démarrages à froid, le déploiement du modèle sur un point de terminaison d'inférence sans serveur serait plus rentable.

Inférence sans serveur Amazon SageMaker est une option d'inférence spécialement conçue pour les charges de travail avec des modèles de trafic imprévisibles et qui peut tolérer les démarrages à froid. Contrairement à un point de terminaison d'inférence en temps réel, qui s'appuie sur une instance de calcul de longue durée, les points de terminaison sans serveur fournissent des ressources à la demande avec une mise à l'échelle automatique intégrée. Les points de terminaison sans serveur évoluent automatiquement en fonction du nombre de requêtes entrantes et réduisent les ressources à zéro lorsqu'il n'y a pas de requêtes entrantes, ce qui vous aide à minimiser vos coûts.

Dans cet article, nous montrons comment déployer des modèles entraînés par Autopilot sur des points de terminaison d'inférence sans serveur à l'aide de Bibliothèques Boto3 en Amazon Sage Maker.

Modes d'entraînement au pilote automatique

Avant de créer une expérience Autopilot, vous pouvez soit laisser Autopilot sélectionner automatiquement le mode d'entraînement, soit sélectionner le mode d'entraînement manuellement.

Le pilote automatique prend actuellement en charge trois modes d'entraînement :

• Automatique – En fonction de la taille de l'ensemble de données, le pilote automatique choisit automatiquement le mode d'assemblage ou le mode HPO. Pour les ensembles de données supérieurs à 100 Mo, Autopilot choisit HPO ; sinon, il choisit l'assemblage.
• Assemblage – Le pilote automatique utilise le AutoGluon technique d'assemblage utilisant l'empilement de modèles et produit un modèle prédictif optimal.
• Optimisation des hyperparamètres (HPO) – Le pilote automatique trouve la meilleure version d'un modèle en ajustant les hyperparamètres à l'aide de l'optimisation bayésienne ou de l'optimisation multi-fidélité lors de l'exécution de tâches d'entraînement sur votre ensemble de données. Le mode HPO sélectionne les algorithmes les plus pertinents pour votre ensemble de données et sélectionne la meilleure gamme d'hyperparamètres pour ajuster vos modèles.

Pour en savoir plus sur les modes d'entraînement au pilotage automatique, reportez-vous à Modes d'entraînement.

Vue d'ensemble de la solution

Dans cet article, nous utilisons le Marketing Banque UCI ensemble de données pour prédire si un client souscrira à un dépôt à terme proposé par la banque. Il s'agit d'un type de problème de classification binaire.

Nous lançons deux tâches de pilote automatique à l'aide de la Bibliothèques Boto3 pour SageMaker. Le premier travail utilise l'assemblage comme mode de formation choisi. Nous déployons ensuite le modèle d'ensemble unique généré sur un point de terminaison sans serveur et envoyons des demandes d'inférence à ce point de terminaison hébergé.

Le deuxième travail utilise le mode de formation HPO. Pour les types de problème de classification, Autopilot génère trois conteneurs d'inférence. Nous extrayons ces trois conteneurs d'inférence et les déployons sur des points de terminaison sans serveur distincts. Ensuite, nous envoyons des demandes d'inférence à ces points de terminaison hébergés.

Pour plus d'informations sur les types de problèmes de régression et de classification, reportez-vous à Définitions de conteneurs d'inférence pour les types de problèmes de régression et de classification.

Nous pouvons également lancer des tâches de pilote automatique à partir du Amazon SageMakerStudio UI. Si vous lancez des travaux à partir de l'interface utilisateur, assurez-vous de désactiver le Déploiement automatique option dans la Déploiement et paramètres avancés section. Sinon, Autopilot déploiera le meilleur candidat sur un point de terminaison en temps réel.

Pré-requis

Assurez-vous que la dernière version de Boto3 et les packages SageMaker Python sont installés :

pip install -U boto3 sagemaker

Nous avons besoin de la version du package SageMaker >= 2.110.0 et version Boto3 >= boto3-1.24.84.

Lancer une tâche Autopilot avec le mode assemblage

Pour lancer un travail Autopilot à l'aide des bibliothèques SageMaker Boto3, nous utilisons le create_auto_ml_job API. Nous passons ensuite dans AutoMLJobConfig, InputDataConfiget une AutoMLJobObjective en tant qu'entrées du create_auto_ml_job. Voir le code suivant:

bucket = session.default_bucket()
role = sagemaker.get_execution_role()
prefix = "autopilot/bankadditional"
sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

timestamp_suffix = strftime('%d%b%Y-%H%M%S', gmtime())
automl_job_name = f"uci-bank-marketing-{timestamp_suffix}"
max_job_runtime_seconds = 3600
max_runtime_per_job_seconds = 1200
target_column = "y"
problem_type="BinaryClassification"
objective_metric = "F1"
training_mode = "ENSEMBLING"

automl_job_config = {
    'CompletionCriteria': {
      'MaxRuntimePerTrainingJobInSeconds': max_runtime_per_job_seconds,
      'MaxAutoMLJobRuntimeInSeconds': max_job_runtime_seconds
    },    
    "Mode" : training_mode
}

automl_job_objective= { "MetricName": objective_metric }

input_data_config = [
    {
      'DataSource': {
        'S3DataSource': {
          'S3DataType': 'S3Prefix',
          'S3Uri': f's3://{bucket}/{prefix}/raw/bank-additional-full.csv'
        }
      },
      'TargetAttributeName': target_column
    }
  ]

output_data_config = {
	    'S3OutputPath': f's3://{bucket}/{prefix}/output'
	}


sm_client.create_auto_ml_job(
				AutoMLJobName=auto_ml_job_name,
				InputDataConfig=input_data_config,
				OutputDataConfig=output_data_config,
				AutoMLJobConfig=automl_job_config,
				ProblemType=problem_type,
				AutoMLJobObjective=automl_job_objective,
				RoleArn=role)

Le pilote automatique renvoie le BestCandidate objet de modèle qui a le InferenceContainers requis pour déployer les modèles aux points de terminaison d'inférence. Pour obtenir le BestCandidate pour le travail précédent, on utilise le describe_automl_job fonction:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_container = job_response['BestCandidate']['InferenceContainers'][0]
print(inference_container)

Déployer le modèle entraîné

Nous déployons maintenant le conteneur d'inférence précédent sur un point de terminaison sans serveur. La première étape consiste à créer un modèle à partir du conteneur d'inférence, puis à créer une configuration de point de terminaison dans laquelle nous spécifions le MemorySizeInMB et les MaxConcurrency valeurs pour le point de terminaison sans serveur avec le nom du modèle. Enfin, nous créons un point de terminaison avec la configuration de point de terminaison créée ci-dessus.

Nous vous conseillons de choisir votre taille de la mémoire du terminal selon la taille de votre modèle. La taille de la mémoire doit être au moins aussi grande que la taille de votre modèle. Votre point de terminaison sans serveur a une taille de RAM minimale de 1024 1 Mo (6144 Go) et la taille de RAM maximale que vous pouvez choisir est de 6 XNUMX Mo (XNUMX Go).

Les tailles de mémoire que vous pouvez choisir sont 1024 Mo, 2048 Mo, 3072 Mo, 4096 Mo, 5120 Mo ou 6144 Mo.

Pour vous aider à déterminer si un point de terminaison sans serveur est la bonne option de déploiement du point de vue des coûts et des performances, nous vous encourageons à consulter le Kit d'outils d'analyse comparative d'inférence sans serveur SageMaker, qui teste différentes configurations de points de terminaison et compare la plus optimale à une instance d'hébergement en temps réel comparable.

Notez que les points de terminaison sans serveur acceptent uniquement SingleModel pour les conteneurs d'inférence. Le pilote automatique en mode assemblage génère un modèle unique, nous pouvons donc déployer ce conteneur de modèle tel quel sur le point de terminaison. Voir le code suivant :

# Create Model
	model_response = sm_client.create_model(
				ModelName=model_name,
				ExecutionRoleArn=role,
				Containers=[inference_container]
	)

# Create Endpoint Config
	epc_response = sm_client.create_endpoint_config(
		EndpointConfigName = endpoint_config_name,
		ProductionVariants=[
			{
				"ModelName": model_name,
				"VariantName": "AllTraffic",
				"ServerlessConfig": {
					"MemorySizeInMB": memory,
					"MaxConcurrency": max_concurrency
				}
			}
		]
	)

# Create Endpoint
	ep_response = sm_client.create_endpoint(
		EndpointName=endpoint_name,
		EndpointConfigName=endpoint_config_name
	)

Lorsque le point de terminaison d'inférence sans serveur est InService, nous pouvons tester le point de terminaison en envoyant une demande d'inférence et observer les prédictions. Le schéma suivant illustre l'architecture de cette configuration.

Notez que nous pouvons envoyer des données brutes en tant que charge utile au point de terminaison. Le modèle d'ensemble généré par Autopilot intègre automatiquement toutes les étapes de transformation d'entités et d'étiquettes inverses requises, ainsi que le modèle d'algorithme et les packages, dans un modèle unique.

Envoyer une demande d'inférence au modèle formé

Utilisez le code suivant pour envoyer une inférence sur votre modèle formé à l'aide du mode d'assemblage :

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer


payload = "34,blue-collar,married,basic.4y,no,no,no,telephone,may,tue,800,4,999,0,nonexistent,1.1,93.994,-36.4,4.857,5191.0"

predictor = Predictor(
        endpoint_name=endpoint,
        sagmaker_session=session,
        serializer=CSVSerializer(),
    )

prediction = predictor.predict(payload).decode(‘utf-8’)
print(prediction)

Lancer un Job Autopilot avec le mode HPO

En mode HPO, pour CompletionCriteria, outre MaxRuntimePerTrainingJobInSeconds et les MaxAutoMLJobRuntimeInSeconds, on pourrait aussi préciser le MaxCandidates pour limiter le nombre de candidats qu'un travail de pilote automatique générera. Notez qu'il s'agit de paramètres facultatifs et qu'ils ne sont définis que pour limiter le temps d'exécution du travail pour la démonstration. Voir le code suivant :

training_mode = "HYPERPARAMETER_TUNING"

automl_job_config["Mode"] = training_mode
automl_job_config["CompletionCriteria"]["MaxCandidates"] = 15
hpo_automl_job_name =  f"{model_prefix}-HPO-{timestamp_suffix}"

response = sm_client.create_auto_ml_job(
					  AutoMLJobName=hpo_automl_job_name,
					  InputDataConfig=input_data_config,
					  OutputDataConfig=output_data_config,
					  AutoMLJobConfig=automl_job_config,
					  ProblemType=problem_type,
					  AutoMLJobObjective=automl_job_objective,
					  RoleArn=role,
					  Tags=tags_config
				)

Pour obtenir le BestCandidate pour le travail précédent, nous pouvons à nouveau utiliser le describe_automl_job fonction:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
best_candidate = job_response['BestCandidate']
inference_containers = job_response['BestCandidate']['InferenceContainers']
print(inference_containers)

Déployer le modèle entraîné

Le pilote automatique en mode HPO pour le type de problème de classification génère trois conteneurs d'inférence.

Le premier conteneur gère les étapes de transformation des fonctionnalités. Ensuite, le conteneur d'algorithme génère le predicted_label avec la probabilité la plus élevée. Enfin, le conteneur d'inférence de post-traitement effectue une transformation inverse sur l'étiquette prédite et la mappe à l'étiquette d'origine. Pour plus d'informations, reportez-vous à Définitions de conteneurs d'inférence pour les types de problèmes de régression et de classification.

Nous extrayons ces trois conteneurs d'inférence et les déployons sur des points de terminaison sans serveur distincts. Pour l'inférence, nous invoquons les points de terminaison dans l'ordre en envoyant d'abord la charge utile au conteneur de transformation de fonctionnalités, puis en transmettant la sortie de ce conteneur au conteneur d'algorithme, et enfin en transmettant la sortie du conteneur d'inférence précédent au conteneur de post-traitement, qui produit l'étiquette prédite.

Le schéma suivant illustre l'architecture de cette configuration.

Nous extrayons les trois conteneurs d'inférence de la BestCandidate avec le code suivant:

job_response = sm_client.describe_auto_ml_job(AutoMLJobName=automl_job_name)
inference_containers = job_response['BestCandidate']['InferenceContainers']

models = list()
endpoint_configs = list()
endpoints = list()

# For brevity, we've encapsulated create_model, create endpoint_config and create_endpoint as helper functions
for idx, container in enumerate(inference_containers):
    (status, model_arn) = create_autopilot_model(
								    sm_client,
								    automl_job_name,
            						role,
								    container,
								    idx)
    model_name = model_arn.split('/')[1]
    models.append(model_name)

    endpoint_config_name = f"epc-{model_name}"
    endpoint_name = f"ep-{model_name}"
    (status, epc_arn) = create_serverless_endpoint_config(
								    sm_client,
								    endpoint_config_name,
								    model_name,
            						memory=2048,
								    max_concurrency=10)
	endpoint_configs.append(endpoint_config_name)

	response = create_serverless_endpoint(
								    sm_client,
								    endpoint_name,
								    endpoint_config_name)
	endpoints.append(endpoint_name)

Envoyer une demande d'inférence au modèle formé

Pour l'inférence, nous envoyons la charge utile dans l'ordre : d'abord au conteneur de transformation de caractéristiques, puis au conteneur de modèle et enfin au conteneur de transformation d'étiquette inverse.

Voir le code suivant:

from sagemaker.predictor import Predictor
from sagemaker.serializers import CSVSerializer

payload = "51,technician,married,professional.course,no,yes,no,cellular,apr,thu,687,1,0,1,success,-1.8,93.075,-47.1,1.365,5099.1"


for _, endpoint in enumerate(endpoints):
    try:
        print(f"payload: {payload}")
        predictor = Predictor(
            endpoint_name=endpoint,
            sagemaker_session=session,
            serializer=CSVSerializer(),
        )
        prediction = predictor.predict(payload)
        payload=prediction
    except Exception as e:
        print(f"Error invoking Endpoint; {endpoint} n {e}")
        break

L'implémentation complète de cet exemple est disponible dans le jupyter suivant cahier.

Nettoyer

Pour nettoyer les ressources, vous pouvez supprimer les points de terminaison sans serveur, les configurations de points de terminaison et les modèles créés :

sm_client = boto3.Session().client(service_name='sagemaker',region_name=region)

for _, endpoint in enumerate(endpoints):
    try:
        sm_client.delete_endpoint(EndpointName=endpoint)
    except Exception as e:
        print(f"Exception:n{e}")
        continue
        
for _, endpoint_config in enumerate(endpoint_configs):
    try:
        sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

for _, autopilot_model in enumerate(models):
    try:
        sm_client.delete_model(ModelName=autopilot_model)
    except Exception as e:
        print(f"Exception:n{e}")
        continue

Conclusion

Dans cet article, nous avons montré comment nous pouvons déployer des modèles générés par le pilote automatique à la fois en mode ensemble et en mode HPO sur des points de terminaison d'inférence sans serveur. Cette solution peut accélérer votre capacité à utiliser et à tirer parti de services ML rentables et entièrement gérés comme Autopilot pour générer rapidement des modèles à partir de données brutes, puis les déployer sur des points de terminaison d'inférence sans serveur entièrement gérés avec une mise à l'échelle automatique intégrée pour réduire les coûts. .

Nous vous encourageons à essayer cette solution avec un ensemble de données pertinent pour les KPI de votre entreprise. Vous pouvez vous référer à la solution implémentée dans un notebook Jupyter dans le GitHub repo.

Références supplémentaires

À propos de l’auteur

Praveen Chamarthi est un spécialiste principal de l'IA/ML chez Amazon Web Services. Il est passionné par l'IA/ML et tout ce qui concerne AWS. Il aide les clients à travers les Amériques à faire évoluer, innover et exploiter efficacement les charges de travail ML sur AWS. Pendant son temps libre, Praveen aime lire et aime les films de science-fiction.