Modèle d'apprentissage automatique Delply avec Heroku et FastAPI

Cet article a été publié dans le cadre du Blogathon sur la science des données

introduction

Je vais vous guider tout au long du processus de Implémenter un modèle d'apprentissage automatique en tant qu'API à l'aide de FastAPI et Heroku. Choses abordées dans cet article:

1. Une introduction rapide à l'ensemble de données et au modèle
2. Principes de base de FastAPI
3. Comment structurer votre code pour utiliser le modèle ML
4. Comment tester et récupérer cette API?
5. Implémentation dans Heroku
6. Bono: Génération de documents

Le jeu de données et le modèle

L'énoncé du problème que j'ai choisi pour cette série d'articles est la classification des genres musicaux. L'ensemble de données a été compilé par un groupe de recherche appelé The Echo Nest. Contient divers détails techniques sur la musique. Ceux-ci inclus Acoustique, danse, énergie, instrumentalité, vivacité, parle, tempo et valence. La variable objective de ces données est de savoir si la chanson appartient au genre Rock ou Hip-Hop.. Ensuite, quelques détails sur l'ensemble de données sont affichés:

L'identification de la piste n'a pas été utile pour notre analyse et, donc, il a été supprimé. Genre_top est notre variable de destination et contient “Roche” O “Hip hop”. J'ai formé un classificateur d'arbre de décision pour cet ensemble de données et j'ai obtenu un bon score de précision. (Je n'ai pas essayé d'autres modèles d'ensemble comme Random Forest, mais tu peux essayer).

Une fois que vous avez fini d'ajuster le modèle et de le tester avec des données aléatoires, il est temps de sélectionner le modèle. Le stripping est le processus de conversion d'un objet Python en un flux d'octets. Enregistrez le modèle sous forme de fichier afin qu'il soit accessible / charger plus tard. Voici le code pour le même si vous n'êtes pas familier:

pkl_filename="modèle.pkl"
avec ouvert(pkl_filename, 'wb') comme f:
    cornichon.dump(maquette, F)

Introduction à FastAPI

C'est un framework web qui accélère le développement backend d'un site web en utilisant Python. Ce cadre est neuf, adaptable et facile à apprendre. Permet aux utilisateurs de configurer rapidement l'API, génère des documents automatiques pour tous les terminaux, propose une authentification, la validation des données, permet le code asynchrone et bien plus encore. Il est construit sur Starlette, qu'est-ce qu'un cadre / boîte à outils ASGI légère et fournit du code prêt pour la production.

D'un autre côté, Flask est plus ancien que FastAPI mais toujours utilisé pour de nombreux projets. Son approche minimaliste est prometteuse et la création d'API flask n'est pas si difficile non plus. Les deux frameworks ont leurs avantages et leurs inconvénients.

Consultez cet article pour une comparaison détaillée de FastAPI: Est le bon remplacement pour les flacons?

Pour mettre en œuvre notre modèle d'apprentissage automatique, nous utiliserons l'approche FastAPI. Avant de plonger dans le code pour créer l'API du modèle, comprenons quelques bases de FastAPI qui aideront à mieux comprendre la base de code.

Principes de base de FastAPI

La structure du code FastAPI est très similaire à la structure de l'application Flask. Vous devez créer des points de terminaison où notre service client peut faire des demandes et obtenir les données requises. Voir l'implémentation du code de base ci-dessous:

importer de l'uvicorne

de fastapi importer FastAPI

application = FastAPI()

@app.get('/')

indice de déf():

    revenir {'un message': "Ceci est la page d'accueil de cette API. Allez dans /apiv1/ ou /apiv2/?nom="}

@app.get('/apiv1 /{Nom}')

par défaut api1(Nom: str):

    revenir {'un message': f'Bonjour! @{Nom}'}

@app.get('/apiv2 /')

par défaut api2(Nom: str):

    revenir {'un message': f'Bonjour! @{Nom}'}

if __name__ == '__main__':

    uvicorn.run(application, hôte="127.0.0.1", port=4000, debug=True)

1. Les deux premières lignes importent FastAPI et uvicor. L'Uvicorn est utilisé pour implémenter le serveur et gérer tous les appels en Python.
2. Ensuite, une instance de l'application FastAPI est créée.
3. Pour ajouter des itinéraires / points de terminaison de cette instance d'application, une fonction est créée et un décorateur de route est ajouté. Ce décorateur enregistre la fonction pour l'itinéraire défini de sorte que lorsque cet itinéraire particulier est demandé, la fonction est appelée et son résultat est retourné au client. Généralement, nous retournons un objet JSON afin qu'il puisse être analysé dans n'importe quel langage.
4. La meilleure partie de FastAPI est que vous pouvez définir ces routes directement pour les méthodes HTTP. Dans le flacon, vous devez les ajouter manuellement à une liste de méthodes (mis à jour sur le flacon 2.0).
5. Pour obtenir les commentaires des clients, vous pouvez utiliser des paramètres de chemin, paramètres de requête ou corps de requête. Le chemin "/apiv1 / {nom}« Mette en œuvre une approche basée sur les routes où les paramètres sont transmis en tant que routes. La route “/ apiv2 /” implémente une approche basée sur les requêtes où les paramètres sont passés en ajoutant le “?” à la fin de l'URL et en utilisant “&” pour ajouter plusieurs paramètres.

Voir ces itinéraires en action:

Demander la mise au point du corps

Avec cette approche, les données client peuvent être transmises à notre API. Et FastAPI, pour simplifier les choses, nous utilisons des modèles Pydantic pour définir la structure de données pour les données de réception. Pydantic effectue tous les types de vérification des paramètres et renvoie des erreurs explicables si le mauvais type de paramètre est reçu. Ajoutons une classe de données à notre code existant et créons un chemin pour le corps de la requête:

.

.

# Après les autres importations
de pydantic importer BaseModel
Détails de la classe(Modèle de base):
    nom_de_f: str
    l_nom: str
    numéro de téléphone: entier
application = FastAPI()

.
.
.

# Après d'anciens itinéraires
@app.post('/apiv3 /')
par défaut api3(Les données: Des détails):
    revenir {'un message': Les données}

La fonction path déclare un paramètre “Les données” du genre “Détails” défini ci-dessus. Ce modèle de “Détails” hérite du modèle de base de Pydantic et offre la validation des données. Pour tester cet itinéraire, J'utilise l'extension de code VS du client Thunder pour faire une demande de publication sur notre chemin d'API “/ apiv3 /”:

Envelopper le modèle

Maintenant que nous avons supprimé les concepts de FastAPI, il est temps d'intégrer le modèle dans la structure de code FastAPI pour faire des requêtes de prédiction. Nous allons créer un itinéraire “/ prédiction” qui prendra les données envoyées par le corps de la requête client et notre API renverra la réponse sous forme d'objet JSON contenant le résultat. Regardons d'abord le code et ensuite j'expliquerai la mécanique:

importer de l'uvicorne

importer des cornichons

de fastapi importer FastAPI

de pydantic importer BaseModel

classe Musique(Modèle de base):

    acoustique: flotter

    danse: flotter

    énergie: flotter

    instrumentalité: flotter

    vivacité: flotter

    discours: flotter

    tempo: flotter

    valence: flotter

application = FastAPI()




avec ouvert("./Fichiers FastAPI/model.pkl", "rb") comme f:

    modèle = pickle.load(F)

@app.get('/')

indice de déf():

    revenir {'un message': 'Ceci est la page d'accueil de l'API'}

@app.post('/prédiction')

def get_music_category(Les données: Musique):

    reçu = data.dict()

    acoustique = reçu['acoustique']

    danse = reçu['dansabilité']

    énergie = reçue['énergie']

    instrumentalité = reçu[« instrumentalité »]

    vivacité = reçu['vivant']

    parole = reçu['parole']

    tempo = reçu['conditions météorologiques']

    valence = reçu['valence']

    pred_name = model.predict([[acoustique, danse, énergie,

                                instrumentalité, vivacité, discours, conditions météorologiques, valence]]).lister()[0]

    revenir {'prédiction': pred_name}

if __name__ == '__main__':

    uvicorn.run(application, hôte="127.0.0.1", port=4000, debug=True)

1. Nous avons créé une classe Music Model qui définit tous les paramètres de notre modèle ML. Toutes les valeurs sont de type float.
2. Ensuite, nous chargeons le modèle en le détachant et en enregistrant le modèle sous “maquette”. Cet objet modèle sera utilisé pour obtenir les prédictions.
3. La fonction chemin “/ prédiction” déclarer un paramètre appelé “Les données” du type de modèle “Chanson”. Ce paramètre est accessible sous forme de dictionnaire. L'objet dictionnaire va nous permettre d'accéder aux valeurs des paramètres sous forme de paires clé-valeur.
4. À présent, nous sauvegardons toutes les valeurs des paramètres envoyées par le client. Ces valeurs sont maintenant introduites dans la fonction de prédiction du modèle et nous avons notre prédiction pour les données fournies.

Tous les codes abordés dans cet article sont disponibles sur mon dépôt GitHub.

Test d'API modèle

Il est maintenant temps de tester l'API. Vous pouvez tester l'API via deux méthodes:

Client Tonnerre / facteur

Nous utilisons le client Thunder pour envoyer une demande de publication au chemin “/ prédiction” avec un corps de requête. Le corps de la requête contient les paires clé-valeur des paramètres et nous devrions nous attendre à une réponse JSON avec le genre musical classifié.

Faire une demande en utilisant le module de demande

Si vous ne souhaitez pas utiliser les extensions VSCode ou tout logiciel de test d'API, vous pouvez simplement créer un programme python distinct pour appeler cette API. Le module de requêtes Python permet d'appeler des API.

demandes d'importation
importer json

URL = "<URL-hôte-local>/prédiction"

charge utile = json.dumps({
  "acoustique": 0.344719513,
  "danse": 0.758067547,
  "énergie": 0.323318405,
  "instrumentalité": 0.0166768347,
  "vivacité": 0.0856723112,
  "discours": 0.0306624283,
  "conditions météorologiques": 101.993,
  "valence": 0.443876228
})

en-têtes = {
  'Type de contenu': 'application/json'
}

réponse = demandes.demande("PUBLIER", URL, en-têtes=en-têtes, données=charge utile)

imprimer(réponse.texte)

Remplacer “URL-hôte-local” avec votre url que vous obtenez après avoir exécuté le fichier API du modèle FastAPI. La sortie pour ceci est:

Viva! Vous avez créé avec succès une API pour votre modèle d'apprentissage automatique à l'aide de FastAPI.

Implémentation dans Heroku

Notre API est prête à être utilisée par tout type de programme qui fait appel à notre API. Mais vous ne pouvez pas exécuter ce programme toute la journée sur votre système local, c'est pratiquement impossible. Donc, vous devez déployer votre service sur une plate-forme cloud qui peut exécuter votre code et renvoyer des retours.

Heroku est l'une de ces plateformes qui propose un hébergement gratuit. Pour implémenter notre API dans Heroku, nous devons créer ces fichiers:

1. Exigences.txt: Ce fichier doit lister tous les modules externes que vous avez utilisés dans votre application. Pour notre cas, était FastAPI, scikit-apprendre, uvicorn et quelques autres modules auxiliaires.
2. runtime.txt: Ce fichier spécifie la version de Python que Heroku installera sur son point de terminaison.
3. Profil: Ce fichier est le fichier d'interface entre notre code Python et la plateforme Heroku. Noter: la plupart d'entre vous ne créent pas correctement ce fichier. Ce n'est pas un fichier texte. Ce fichier n'a pas d'extension. Pour créer de tels fichiers, vous pouvez utiliser GitHub pour ajouter des fichiers ou du code Vs ou cmd sous Windows ou un terminal sous Linux. Ce fichier contiendrait la commande suivante pour FastAPI:

la toile: gunicorne -w 4 -k uvicorn.workers.UvicornWorker :application

Ici, remplacez file_name par le nom du fichier Python dans lequel vous avez créé le code FastAPI. Après ça:

1. Mettez tous ces fichiers (maquette, fichier python, exigences.txt, Profil) dans un dépôt GitHub
2. Connectez-vous à Heroku et créez une nouvelle application. Connectez votre dépôt GitHub
3. Cliquez sur Déployer la branche et votre API sera opérationnelle pour que tout le monde puisse l'utiliser avec le lien.

Bono: Génération de documents

FastAPI a une fonction spéciale. Générer automatiquement des documents pour les points de terminaison d'API créés. Pour accéder à ces documents, il suffit de visiter le point final “/ documents” et vous obtiendrez une interface utilisateur graphique attrayante créée avec Swagger et OpenAI. Maintenant que nous avons mis en place le service, la capture d'écran ci-dessous provient de l'application Heroku déployée. (Relier: https://kivymlapp.herokuapp.com/)

conclusion

Dans cet article détaillé, le presenté FastAPI, ses bases, comment créer un fichier API pour le modèle d'apprentissage automatique, comment tester cette API et comment implémenter cette API sur la plateforme Heroku. Nous avons également vu comment accéder au point de terminaison du document que FastAPI génère automatiquement.

Dans le prochain article, Je vais montrer comment utiliser l'API créée dans cet article pour créer une application de prédiction musicale Android à l'aide de Python et nous allons également convertir ce fichier de Python en APK.

Noter: tu peux utiliser ce lien, Lien maître vers tous mes articles sur Internet, qui se met à jour chaque fois que je poste un nouvel article pour trouver cet article.

Si vous avez aucun doute, enquête ou opportunité potentielle, alors vous pouvez communiquer avec moi à travers

1. Linkedin – dans / kaustubh-gupta /

2. Twitter – @ Kaustubh1828

3. GitHub – kaustubhgupta

En rapport