Een aspect van het scenario is het creëren van een machine learning-model. Het moet bruikbaar zijn in de echte wereld en beschikbaar zijn voor consumenten en ontwikkelaars.
De eenvoudigste en populairste manier om machine learning-modellen te implementeren, is door ze in te sluiten in een REST API.
Met een populaire bibliotheek genaamd FastAPI is dat precies wat we vandaag zullen bereiken.
Maar wat is? FastAPI?
Het FastAPI Python-webframework is vanaf het begin gemaakt om te profiteren van de hedendaagse Python-mogelijkheden.
Voor asynchrone, gelijktijdige communicatie met klanten voldoet het aan de ASGI-standaard, terwijl het ook in staat is om WSGI te gebruiken.
Eindpunten en routes kunnen beide gebruikmaken van asynchrone functies. Bovendien maakt FastAPI de productieve creatie van web-apps mogelijk in type-hint, schone, moderne Python-code.
De belangrijkste use-case van FastAPI is, zoals de naam al doet vermoeden, het maken van API-eindpunten.
Het gebruik van de OpenAPI-standaard, die een interactieve Swagger-gebruikersinterface bevat, of het leveren van Python-woordenboekgegevens als JSON zijn beide eenvoudige manieren om dit te bereiken. FastAPI is echter niet alleen voor API's.
Het kan worden gebruikt om standaard webpagina's aan te bieden met behulp van de Jinja2-sjabloonengine en om apps te bedienen die WebSockets gebruiken, naast vrijwel al het andere dat een webframework kan doen.
In dit artikel zullen we een eenvoudig machine learning-model ontwikkelen en vervolgens FastAPI gebruiken om het te implementeren. Laten we beginnen.
Installatie van FastAPI en creatie van de eerste API
Het installeren van de bibliotheek en een ASGI-server is eerst vereist; ofwel Uvuicorn of Hypercorn zal werken. Het werkt door de volgende opdracht in de Terminal in te voeren:
Nu de API is gemaakt, kunt u uw favoriete code-editor gebruiken en er doorheen bladeren. Maak een Python-script met de naam ml_model.py om aan de slag te gaan. Je mag de jouwe een andere naam geven, maar omwille van dit bericht zal ik naar dit bestand verwijzen als ml_model.py.
Om een eenvoudige API met twee eindpunten te maken, moet u de volgende taken uitvoeren:
- Importeer de FastAPI- en Uvicorn-bibliotheken.
- Stel een instantie van een FastAPI-klasse in.
- Declareer de eerste route, die op de indexpagina een rechttoe rechtaan JSON-object produceert.
- Declareer de tweede route, die een eenvoudig JSON-object met een aangepast bericht biedt. De naamparameter wordt rechtstreeks uit de URL gehaald (bijvoorbeeld https://127.0.0.1:8000/Jay).
- Gebruik Uvicorn om de API uit te voeren.
Het implementeren van deze vijf fasen wordt getoond in het volgende stukje code, dwz. een eenvoudige API maken
Helemaal klaar! Laten we onze API onmiddellijk lanceren. Open hiervoor een Terminal-venster naast het ml model.py-bestand. Voer vervolgens het volgende in:
de Enter-toets. Laten we, voordat we verder gaan, deze bewering ontkrachten. De eerste app maakt alleen gebruik van de Python-bestandsnaam, zonder de extensie. De tweede app moet dezelfde naam hebben als uw FastAPI-instantie.
Door -reload te gebruiken, vertelt u de API dat u wilt dat deze automatisch opnieuw wordt geladen wanneer u het bestand opslaat in plaats van helemaal opnieuw te beginnen.
Start nu een browser en navigeer naar https://127.0.0.1:8000; het resultaat zou er als volgt uit moeten zien:
U begrijpt nu hoe u een eenvoudige API kunt maken met FastAPI.
Het Machine Learning-model bouwen en trainen
Zonder data te verzamelen of te analyseren, trainen we gewoon een eenvoudig model. Deze staan los van de inzet van modellen en zijn niet essentieel voor het onderwerp dat aan de orde is.
Een model gebaseerd op de Iris-dataset kan met dezelfde worden geïnstalleerd neuraal netwerk installatie methode.
En dat doen we: download de Iris-gegevensset en train het model. Dat zal niet eenvoudig zijn. Maak om te beginnen een bestand met de naam jaysmlmodel.py.
Daarin doe je het volgende:
- Imports - Je hebt panda's, scikit-RandomForecastClassifier, Learn's pydantic's BaseModel nodig (je zult in de volgende stap ontdekken waarom), en joblib voor het opslaan en laden van modellen.
- Declareer een IrisSpecies-klasse die erft van het basismodel. Deze klasse bevat alleen velden die nodig zijn om een enkele bloemsoort te voorspellen (daarover meer in de volgende sectie)
- Maak een klas aan. IrisModel is een tool voor het trainen en voorspellen van modellen.
- Declareer een methode met de naam _train model binnen IrisModel. Het wordt gebruikt om modellen te trainen met behulp van de Random Forests-techniek. Het getrainde model wordt geretourneerd door de procedure.
- Declareer een voorspelde soortfunctie binnen IrisModel. Het wordt gebruikt om te voorspellen op basis van 4 inputfactoren (bloemmetingen). Zowel de voorspelling (bloemsoort) als de voorspellingskans worden door het algoritme geretourneerd.
- Wijzig de constructor in IrisModel zodat deze de Iris-gegevensset laadt en het model traint als deze in de map ontbreekt. Dit lost het probleem op van het herhaaldelijk trainen van nieuwe modellen. De joblib-bibliotheek wordt gebruikt voor het laden en opslaan van modellen.
Hier is de hele code:
Ik hoop dat de bovenstaande lijst en de opmerkingen het gemakkelijk maakten om te begrijpen, ook al was dit een aanzienlijke hoeveelheid code om te maken. Laten we, nu dit model is ontwikkeld, de voorspellingsmogelijkheden ervan publiceren over een periode van REST API.
Een volledige REST API bouwen
Keer terug naar het bestand ml_model.py en verwijder alle gegevens. De standaardtekst zal in wezen hetzelfde zijn als wat u eerder had, maar we moeten opnieuw beginnen met een leeg bestand.
U definieert deze keer slechts één eindpunt, namelijk het eindpunt dat wordt gebruikt om het type bloem te bepalen. IrisModel.predict species(), die in de vorige sectie is gedeclareerd, wordt door dit eindpunt aangeroepen om de voorspelling uit te voeren.
Het verzoektype is de andere grote verandering. Om parameters in JSON in plaats van URL te verzenden, wordt aanbevolen dat u POST gebruikt wanneer u gebruikt machine learning API's.
De bovenstaande zin klonk misschien als gebrabbel als je een data scientist, maar dat is goed. Om modellen te ontwerpen en te implementeren, hoeft men niet per se een expert te zijn op het gebied van HTTP-verzoeken en REST API's.
De taken voor ml model.py zijn weinig en eenvoudig:
- U moet het volgende importeren uit het eerder gemaakte bestand jaymlmodel.py: uvicorn, FastAPI, IrisModel en IrisSpecies.
- Maak instanties van FastAPI en IrisModel.
- Declareer een functie op https://127.0.0.1:8000/predict om voorspellingen te doen.
- De methode IrisModel.predict species() ontvangt een object van het type IrisSpecies, transformeert het naar een woordenboek en retourneert het vervolgens. Rendementen zijn de verwachte klasse en voorspelde waarschijnlijkheid.
- Gebruik uvicorn om de API uit te voeren.
Nogmaals, hier is de code van het hele bestand samen met de opmerkingen:
Dat is alles wat u hoeft te doen. Laten we in de volgende stap de API testen.
Testen van de API
Voer de volgende regel opnieuw in de Terminal in om de API uit te voeren: uvicorn ml_model:app –reload
Zo ziet de documentatiepagina eruit:
Dus dat was het voor vandaag. Laten we in het deel hierna besluiten.
Conclusie
Vandaag heb je geleerd wat FastAPI is en hoe je het moet gebruiken, met behulp van zowel een eenvoudig API-voorbeeld als een eenvoudig voorbeeld van machine learning. U hebt ook geleerd hoe u API-documentatie kunt maken en bekijken, en hoe u deze kunt testen.
Dat is veel voor een enkel stuk, dus wees niet verbaasd als er een paar metingen nodig zijn om het goed te begrijpen.
Happy codering.
Laat een reactie achter