Réduisez le temps nécessaire au déploiement de vos modèles sur Amazon SageMaker pour les tests

Les scientifiques des données forment souvent leurs modèles localement et recherchent un service d'hébergement approprié pour déployer leurs modèles. Malheureusement, il n'existe pas de mécanisme ou de guide unique pour déployer des modèles pré-formés dans le cloud. Dans cet article, nous examinons le déploiement de modèles entraînés pour Amazon Sage Maker hébergement pour réduire votre temps de déploiement.

SageMaker est un service d'apprentissage automatique (ML) entièrement géré. Avec SageMaker, vous pouvez rapidement créer et former des modèles ML et les déployer directement dans un environnement hébergé prêt pour la production. De plus, vous n'avez pas besoin de gérer les serveurs. Vous obtenez un environnement de bloc-notes Jupyter intégré avec un accès facile à vos sources de données. Vous pouvez effectuer une analyse des données, former vos modèles et les tester à l'aide de vos propres algorithmes ou utiliser les algorithmes ML fournis par SageMaker qui sont optimisés pour s'exécuter efficacement sur de grands ensembles de données répartis sur plusieurs machines. La formation et l'hébergement sont facturés à la minute d'utilisation, sans frais minimum et sans engagement initial.

Vue d'ensemble de la solution

Les scientifiques des données forment parfois des modèles localement à l'aide de leur IDE et expédient ces modèles à l'équipe d'ingénierie ML pour déploiement ou exécutent simplement des prédictions localement sur des machines puissantes. Dans cet article, nous présentons une bibliothèque Python qui simplifie le processus de déploiement de modèles sur SageMaker pour hébergement sur des points de terminaison en temps réel ou sans serveur.

Cette bibliothèque Python offre aux scientifiques des données une interface simple pour démarrer rapidement sur SageMaker sans avoir besoin de connaître les fonctionnalités de bas niveau de SageMaker.

Si vous avez des modèles formés localement à l'aide de votre IDE préféré et que vous souhaitez bénéficier de l'échelle du cloud, vous pouvez utiliser cette bibliothèque pour déployer votre modèle sur SageMaker. Avec SageMaker, en plus de tous les avantages de mise à l'échelle d'une plate-forme ML basée sur le cloud, vous avez accès à des outils de formation spécialement conçus (formation distribuée, réglage d'hyperparamètres), à la gestion des expériences, à la gestion des modèles, à la détection des biais, à l'explicabilité des modèles et bien d'autres. des fonctionnalités qui peuvent vous aider dans tous les aspects du cycle de vie ML. Vous pouvez choisir parmi les trois frameworks les plus populaires pour le ML : Scikit-learn, PyTorch et TensorFlow, et choisir le type de calcul que vous souhaitez. Des valeurs par défaut sont fournies en cours de route afin que les utilisateurs de cette bibliothèque puissent déployer leurs modèles sans avoir à prendre de décisions complexes ou à apprendre de nouveaux concepts. Dans cet article, nous vous montrons comment démarrer avec cette bibliothèque et optimiser le déploiement de vos modèles ML sur l'hébergement SageMaker.

La bibliothèque se trouve dans le GitHub référentiel.

La boîte à outils de migration SageMaker

Les SageMakerMigration La classe est disponible via une bibliothèque Python publiée sur GitHub. Les instructions d'installation de cette bibliothèque sont fournies dans le référentiel ; assurez-vous de suivre le README pour configurer correctement votre environnement. Après avoir installé cette bibliothèque, le reste de cet article explique comment vous pouvez l'utiliser.

Les SageMakerMigration La classe se compose d'abstractions de haut niveau sur les API SageMaker qui réduisent considérablement les étapes nécessaires pour déployer votre modèle sur SageMaker, comme illustré dans la figure suivante. Ceci est destiné à l'expérimentation afin que les développeurs puissent rapidement démarrer et tester SageMaker. Il n'est pas destiné aux migrations de production.

Pour les modèles Scikit-learn, PyTorch et TensorFlow, cette bibliothèque prend en charge le déploiement de modèles formés sur un point de terminaison en temps réel SageMaker ou un point de terminaison sans serveur. Pour en savoir plus sur les options d'inférence dans SageMaker, reportez-vous à Déployer des modèles pour l'inférence.

Points de terminaison en temps réel ou sans serveur

L'inférence en temps réel est idéale pour les charges de travail d'inférence où vous avez des exigences en temps réel, interactives et à faible latence. Vous pouvez déployer votre modèle sur les services d'hébergement SageMaker et obtenir un point de terminaison pouvant être utilisé pour l'inférence. Ces points de terminaison sont entièrement gérés et prennent en charge la mise à l'échelle automatique.

SageMaker Serverless Inference est une option d'inférence spécialement conçue qui vous permet de déployer et de mettre à l'échelle facilement des modèles ML. L'inférence sans serveur est idéale pour les charges de travail qui ont des périodes d'inactivité entre les pics de trafic et qui peuvent tolérer les démarrages à froid. Les points de terminaison sans serveur lancent automatiquement les ressources de calcul et les augmentent et diminuent en fonction du trafic, éliminant ainsi le besoin de choisir des types d'instance ou de gérer des politiques de mise à l'échelle. Cela enlève le poids indifférencié de la sélection et de la gestion des serveurs.

Selon votre cas d'utilisation, vous souhaiterez peut-être héberger rapidement votre modèle sur SageMaker sans avoir une instance toujours active et sans encourir de coûts, auquel cas un point de terminaison sans serveur est une excellente solution.

Préparez votre modèle entraîné et votre script d'inférence

Après avoir identifié le modèle que vous souhaitez déployer sur SageMaker, vous devez vous assurer que le modèle est présenté à SageMaker dans le bon format. Les points de terminaison SageMaker se composent généralement de deux composants : l'artefact de modèle formé (.pth, .pkl, etc.) et un script d'inférence. Le script d'inférence n'est pas toujours obligatoire, mais s'il n'est pas fourni, les gestionnaires par défaut du conteneur de service que vous utilisez sont appliqués. Il est essentiel de fournir ce script si vous avez besoin de personnaliser votre fonctionnalité d'entrée/sortie pour l'inférence.

L'artefact de modèle formé est simplement un modèle Scikit-learn, PyTorch ou TensorFlow enregistré. Pour Scikit-learn, il s'agit généralement d'un fichier pickle, pour PyTorch, il s'agit d'un fichier .pt ou .pth, et pour TensorFlow, il s'agit d'un dossier contenant des actifs, des fichiers .pb et d'autres variables.

En règle générale, vous devez pouvoir contrôler la façon dont votre modèle traite les entrées et effectue l'inférence, et contrôler le format de sortie de votre réponse. Avec SageMaker, vous pouvez fournir un script d'inférence pour ajouter cette personnalisation. Tout script d'inférence utilisé par SageMaker doit avoir une ou plusieurs des quatre fonctions de gestionnaire suivantes : model_fn, input_fn, predict_fnet la output_fn.

Notez que ces quatre fonctions s'appliquent à PyTorch ainsi que les Scikit-apprendre conteneurs spécifiquement. TensorFlow a des gestionnaires légèrement différents car il est intégré à Servir TensorFlow. Pour un script d'inférence avec TensorFlow, vous disposez de deux gestionnaires de modèles: input_handler et output_handler. Encore une fois, ceux-ci ont le même objectif de prétraitement et de post-traitement avec lequel vous pouvez travailler, mais ils sont configurés légèrement différemment pour s'intégrer à Servir TensorFlow. Pour les modèles PyTorch, model_fn est une fonction obligatoire à avoir dans le script d'inférence.

modèle_fn

Il s'agit de la fonction qui est appelée en premier lorsque vous appelez votre point de terminaison SageMaker. C'est ici que vous écrivez votre code pour charger le modèle. Par exemple:

def model_fn(model_dir):
    model = Your_Model()
    with open(os.path.join(model_dir, 'model.pth'), 'rb') as f:
        model.load_state_dict(torch.load(f))
    return model

Selon le framework et le type de modèle, ce code peut changer, mais la fonction doit renvoyer un modèle initialisé.

entrée_fn

Il s'agit de la deuxième fonction qui est appelée lorsque votre point de terminaison est appelé. Cette fonction prend les données envoyées au point de terminaison pour inférence et les analyse dans le format requis pour que le modèle génère une prédiction. Par exemple:

def input_fn(request_body, request_content_type):
    """An input_fn that loads a pickled tensor"""
    if request_content_type == 'application/python-pickle':
        return torch.load(BytesIO(request_body))
    else:
        # Handle other content-types here or raise an Exception
        # if the content type is not supported.
        pass

Les request_body contient les données à utiliser pour générer l'inférence à partir du modèle et est analysée dans cette fonction afin qu'elle soit au format requis.

prédire_fn

Il s'agit de la troisième fonction qui est appelée lorsque votre modèle est appelé. Cette fonction prend les données d'entrée prétraitées renvoyées par input_fn et utilise le modèle renvoyé par model_fn pour faire la prédiction. Par exemple:

def predict_fn(input_data, model):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    model.eval()
    with torch.no_grad():
        return model(input_data.to(device))

Vous pouvez éventuellement ajouter output_fn pour analyser la sortie de predict_fn avant de le retourner au client. La signature de la fonction est def output_fn(prediction, content_type).

Déplacez votre modèle pré-formé vers SageMaker

Une fois que vous disposez de votre fichier de modèle entraîné et de votre script d'inférence, vous devez placer ces fichiers dans un dossier comme suit :

#SKLearn Model

model_folder/
    model.pkl
    inference.py
    
# Tensorflow Model
model_folder/
    0000001/
        assets/
        variables/
        keras_metadata.pb
        saved_model.pb
    inference.py
    
# PyTorch Model
model_folder/
    model.pth
    inference.py

Une fois votre modèle et votre script d'inférence préparés et enregistrés dans cette structure de dossiers, votre modèle est prêt à être déployé sur SageMaker. Voir le code suivant :

from sagemaker_migration import frameworks as fwk

if __name__ == "__main__":
    ''' '''
    sk_model = fwk.SKLearnModel(
        version = "0.23-1", 
        model_data = 'model.joblib',
        inference_option = 'real-time',
        inference = 'inference.py',
        instance_type = 'ml.m5.xlarge'
    )
    sk_model.deploy_to_sagemaker()

Après le déploiement de votre point de terminaison, assurez-vous de nettoyer toutes les ressources que vous n'utiliserez pas via la console SageMaker ou via le delete_endpoint Appel de l'API Boto3.

Conclusion

L'objectif du projet SageMaker Migration Toolkit est de permettre aux scientifiques des données d'intégrer facilement leurs modèles dans SageMaker afin de tirer parti de l'inférence basée sur le cloud. Le référentiel continuera d'évoluer et prendra en charge davantage d'options pour la migration des charges de travail vers SageMaker. Le code est open source et nous accueillons les contributions de la communauté par le biais de demandes d'extraction et de problèmes.

Jetez un coup d'œil au GitHub référentiel pour en savoir plus sur l'utilisation de la boîte à outils de migration SageMaker, et n'hésitez pas à contribuer également des exemples ou des demandes de fonctionnalités à ajouter au projet !

À propos des auteurs

Kirit Thadaka est un architecte de solutions ML travaillant dans l'équipe Amazon SageMaker Service SA. Avant de rejoindre AWS, Kirit a passé du temps à travailler dans des startups d'IA en phase de démarrage, suivies d'un certain temps dans le conseil dans divers rôles dans la recherche sur l'IA, les MLOps et la direction technique.

Ram Végiraju est un architecte ML au sein de l'équipe SageMaker Service. Il se concentre sur l'aide aux clients pour créer et optimiser leurs solutions d'IA/ML sur Amazon SageMaker. Dans ses temps libres, il aime voyager et écrire.