Comment déployer un Microservice Serverless Machine Learning avec AWS Lambda, AWS API Gateway et scikit-learn

Dans ce tutoriel, nous déployons un microservice d'apprentissage automatique à l'aide de AWS Lambda, AWS API Gateway et scikit-learn. Le référentiel de code qui l'accompagne se trouve sur https://github.com/patrick-michelberger/serverless-machine-learning.

Avant de commencer, assurez-vous que vous exécutez Python 2.7 ou Python 3.6 et que vous disposez d'un compte AWS valide et que votre fichier d'informations d'identification AWS est correctement installé.

Étape 1: Former un modèle de base

Premièrement, nous formons un modèle de régression logistique de l’arbre de décision à gradient renforcé de 3 classes sur l’ensemble de données de l’iris en utilisant le tutoriel scikit-learn comme guide. Pickle le modèle en tant que model.pkl.

Peu importe la qualité de ce modèle pour les besoins de ce hack, il suffit de faire des prédictions. Voici mon modèle complet de script de formation et de sérialisation.

à partir de jeux de données d'importation sklearn
de sklearn.ensemble import GradientBoostingClassifier
de sklearn.externals importer joblib
# importer des données
iris = datasets.load_iris ()
X = iris.data [:,: 2] # nous ne prenons que les deux premières caractéristiques.
Y = iris.target
# init model
clf = GradientBoostingClassifier (n_estimators = 100, rate_network = 1.0, max_depth = 2, random_state = 0)
# modèle adapté
clf.fit (X, Y)
# enregistrer le modèle
joblib.dump (clf, 'model.pkl')

Étape 2: téléchargez votre modèle sur AWS S3

Nous devons d’abord télécharger notre modèle dans un compartiment S3.

aws s3 cp model.pkl s3: // votrebucketname

Étape 3: Création d'une API de flacon

Créons un répertoire de projet

mkdir serverless-machine-learning
cd serverless-machine-learning

Nous intégrons tout notre code et toutes nos dépendances dans un environnement virtuel.

pip installer virtualenv
virtualenv votre_nom_environnement_virtuel
source votre_nom_environnement_virtuel / bin / activate

Nous sommes maintenant prêts à construire notre API. Créez un répertoire api avec un fichier nommé app.py et écrivez-le dans celui-ci:

de flask import Flask, request, json
importer boto3
pickle d'importation
BUCKET_NAME = 'apprentissage sans serveur'
MODEL_FILE_NAME = 'model.pkl'
app = Flacon (__ nom__)
S3 = boto3.client ('s3', nom_région = 'eu-central-1')
@ app.route ('/', method = ['POST'])
def index ():
    # Corps de la requête d'analyse pour l'entrée du modèle
    body_dict = request.get_json (silent = True)
    data = body_dict ['data']
    
    # Charger le modèle
    model = load_model (MODEL_FILE_NAME)
# Faire des prédictions
    prédiction = model.predict (data) .tolist ()
# Répondre avec le résultat de la prédiction
    résultat = {'prédiction': prédiction}
   
    retourne json.dumps (résultat)
si __name__ == '__main__':
    # écouter sur toutes les IP
    app.run (host = '0.0.0.0')

Le code est fondamentalement explicite. Nous fabriquons un objet Flask, utilisons les fonctions de décorateur 'route' pour définir nos chemins et appelons une fonction d'exécution lorsque nous l'exécutons localement (que vous pouvez confirmer en appelant python api / app.py et en visitant localhost: 5000 dans votre navigateur. )

Pour charger le modèle depuis S3, nous utilisons la fonction d'assistance suivante:

def load_model (clé):
    # Charger le modèle à partir du godet S3
    response = S3.get_object (Bucket = BUCKET_NAME, Key = clé)
# Modèle de cornichon
    model_str = response ['Body']. read ()
    model = pickle.loads (model_str)
    
    modèle de retour

Remarque: le code du référentiel Github utilise une annotation mémoisée pour mettre en cache le fichier de modèle une fois extrait de S3, éliminant ainsi le besoin d'un transfert de données S3 supplémentaire et permettant une prédiction nettement plus rapide.

Étape 4: Configurez AWS Lambda & API Gateway

Nous utilisons une infrastructure appelée Zappa pour créer et configurer automatiquement AWS Lambda et la passerelle API. Considérez-le comme un hébergement Web «sans serveur» pour vos applications Python.

Cela signifie une mise à l'échelle infinie, zéro temps d'indisponibilité, zéro maintenance - et à une fraction du coût de vos déploiements actuels!

Commençons donc: d’abord, nous installons les packages requis dans notre environnement virtuel.

pip installer zappa sklearn numpy scipy

Ensuite, nous initialisons Zappa.

zappa init

Zappa a automatiquement créé le fichier de configuration zappa_settings.json:

{“Dev”:
    {“App_function”: “api.app.app”,
      «Aws_region»: «eu-central-1»,
      “Nom_profil”: “défaut”,
      “Nom_projet”: “apprentissage sans serveur”,
      “Runtime”: “python3.6”,
      “Slim_handler”: vrai,
      "s3_bucket": "zappa-10z1mxwy2"
    }
}

Cela définit un environnement appelé «dev» (plus tard, vous voudrez peut-être ajouter des environnements de «staging» et de «production»), définit le nom du compartiment S3 sur lequel nous allons déployer et pointe Zappa vers un environnement compatible WSGI. fonction, dans ce cas, notre objet application Flask.

En définissant le paramètre de configuration slim_handler sur true, Zappa peut charger du code à partir d'Amazon S3 au cas où notre environnement dépasserait la taille maximale de 50 Mo.

Étape 5: Test de l'API localement

L'API peut être testé localement comme une application Flask classique

Tout d'abord, lancez l'application Flask comme d'habitude:

$ python api / app.py

Deuxièmement, faire un appel API de test

$ http POST localhost: 5000 
# payload.json
{
  "données": [[6.2, 3.4], [6.2, 1]]
}

La réponse devrait être

{"prédiction": [2, 1]}

Étape 6: déploiement sur AWS Lambda

Nous sommes maintenant prêts à déployer sur AWS. C’est aussi simple que:

$ zappa deploy dev

Et notre microservice Machine Learning sans serveur est en vie!

$ http POST https://ic06qkgrbc.execute-api.eu-central-1.amazonaws.com/dev 

Félicitations, vous avez terminé tous les tests requis pour déployer un microservice d’apprentissage automatique sans serveur. J'espère que vous avez apprécié le projet.

Dépôt Github: https://github.com/patrick-michelberger/serverless-machine-learning

Si vous rencontrez des problèmes pour faire fonctionner l'application, n'hésitez pas à me contacter.