कोर्स
FastAPI के साथ प्रोडक्शन में AI डिप्लॉय करना
4 घंटा
5.5K
API (Application Programming Interface) आधुनिक आर्किटेक्चर की रीढ़ हैं क्योंकि वे ऐप्लिकेशनों को मॉड्यूलर और डीकपल्ड बनने देती हैं। इसका अर्थ है कि आप ऐप्लिकेशन तेज़ी और आसानी से बना सकते हैं, और उन्हें आसानी से बनाए रखकर अपडेट कर सकते हैं।
मशीन लर्निंग में भी API बहुत महत्वपूर्ण हैं क्योंकि वे अलग-अलग ऐप्लिकेशनों को डेटा साझा करने और साथ में काम करने की सुविधा देती हैं, जिससे समय और मेहनत बचती है। Python में API बनाने के लिए कई फ़्रेमवर्क उपलब्ध हैं। सबसे लोकप्रिय फ़्रेमवर्क में Django, Flask और FastAPI शामिल हैं। यह ट्यूटोरियल FastAPI नामक फ़्रेमवर्क पर गहराई से केंद्रित है।
यदि आप इस विषय को और गहराई से सीखना चाहते हैं, तो यह कोर्स देखें: Deploying AI Into Production With FastAPI।
API क्या है?
API का अर्थ है Application Programming Interface। API एक सॉफ़्टवेयर मध्यस्थ है जो दो ऐप्लिकेशनों को एक-दूसरे से संवाद करने देता है। जब आप अपने फ़ोन पर कोई ऐप्लिकेशन उपयोग करते हैं, तो ऐप इंटरनेट से कनेक्ट होकर किसी सर्वर को डेटा भेजता है। सर्वर उस डेटा को प्रोसेस करता है और उसे वापस आपके फ़ोन पर भेजता है। आपके फ़ोन का ऐप फिर उस डेटा को समझकर आपको पढ़ने योग्य रूप में दिखाता है।
API को आप रेस्तरां के वेटर की तरह समझ सकते हैं। वेटर आपका ऑर्डर लेता है और किचन तक पहुँचाता है। किचन खाना तैयार करके वेटर को देता है और वेटर उसे आपके पास लाता है।
इसी तरह, कोई API किसी ऐप्लिकेशन से अनुरोध लेकर उसे सर्वर तक पहुँचाती है। सर्वर अनुरोध को प्रोसेस करता है और डेटा वापस ऐप्लिकेशन को भेजता है। ऐप्लिकेशन फिर उस डेटा को समझकर उपयोगकर्ता को दिखाता है।
Image Source: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png
यदि आप मशीन लर्निंग पाइपलाइनों, API, और MLOps के बारे में और सीखना चाहते हैं, तो हमारा Machine Learning, Pipelines, Deployment and MLOps Tutorial देखें।
FastAPI क्या है
FastAPI Python 3.7+ के साथ API बनाने के लिए एक उच्च-प्रदर्शन वेब फ़्रेमवर्क है जो मानक Python टाइप हिंट्स पर आधारित है। यह डेवलपर्स को ऐप्लिकेशन तेज़ी और कुशलता से बनाने में मदद करता है। FastAPI, Starlette वेब सर्वर पर आधारित है और ऐसी विशेषताएँ शामिल करता है जो वेब ऐप्लिकेशन बनाना आसान बनाती हैं, जैसे स्वचालित डेटा वैलिडेशन, एरर हैंडलिंग, और इंटरैक्टिव API डॉक्यूमेंटेशन।
हम इस खंड में इन सभी विशेषताओं को अलग-अलग देखेंगे। पहले, आइए FastAPI के मूल दस्तावेज़ में बताए गए प्रमुख फीचर्स पर नज़र डालें।
- प्रदर्शन: NodeJS और Go भाषा के समकक्ष।
- गति: विकास की गति 2-3X तक बढ़ाएँ।
- आसान: बढ़िया एडिटर सपोर्ट। हर जगह ऑटो-कम्प्लीशन। सीखने और उपयोग में आसान।
- मजबूत: स्वचालित इंटरैक्टिव डॉक्यूमेंटेशन के साथ प्रोडक्शन-रेडी कोड।
- OpenAPI आधारित: OpenAPI और JSON Schema के साथ पूरी तरह संगत।
FastAPI इंस्टॉल करना
FastAPI के लिए Python 3.7+ आवश्यक है। इसे pip से इंस्टॉल किया जा सकता है। आपको FastAPI और ASGI सर्वर `uvicorn` इंस्टॉल करना होगा।
``
# install fastapi
pip install fastapi
# install uvicorn
pip install uvicorn
``एक साधारण API बनाएँ
आइए सीधे एक बहुत साधारण टॉय API बनाकर शुरू करते हैं। मैं इसे लागू करने के लिए VS Code का उपयोग कर रहा हूँ, लेकिन आप अपनी पसंद का कोई भी संपादक उपयोग कर सकते हैं।
```
from typing import Union
from fastapi import FastAPI
app = FastAPI()
@app.get("")
def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}
```(उदाहरण मूल दस्तावेज़ से पुन: प्रस्तुत)। @tiangolo को धन्यवाद।
अब कमांड लाइन टर्मिनल का उपयोग करके, निम्न कमांड से इस API को चलाएँ:
```
uvicorn main:app –reload
````main` Python फ़ाइल का नाम है, और `app` वह वेरिएबल है जिसमें FastAPI क्लास स्टोर है। आप इन्हें अपनी इच्छा के अनुसार नाम दे सकते हैं। ऊपर दिए गए कमांड को चलाने पर, आपको टर्मिनल पर कुछ इस तरह का आउटपुट दिखाई देगा:
ब्राउज़र में लिंक खोलें, और यदि आपको `Hello World` दिखाने वाला पेज दिखता है, तो API सफलतापूर्वक चल रही है।
Image by Author
अपनी पहली API बनाने पर बधाई।
इंटरैक्टिव API डॉक्यूमेंटेशन
FastAPI आपके सभी API के साथ एक "स्कीमा" जेनरेट करता है, जो API को परिभाषित करने के लिए OpenAPI मानक पर आधारित होता है। "स्कीमा" किसी चीज़ की परिभाषा या विवरण होता है। वह कोड नहीं जो उसे इम्प्लीमेंट करता है, बल्कि उसका अमूर्त विवरण। OpenAPI स्कीमा ही FastAPI में शामिल दो इंटरैक्टिव डॉक्यूमेंटेशन सिस्टम को संचालित करता है।
डॉक्यूमेंटेशन देखने के लिए, बस url में `/docs` जोड़ें (`http://127.0.0.1:8000/docs`)। यह लिंक स्वचालित इंटरैक्टिव API डॉक्यूमेंटेशन दिखाएगा।
Image by Author
API को टेस्ट करने के लिए दाईं ऊपर `Try it out` बटन पर क्लिक करें।
Image by Author
आप देख सकते हैं कि प्रतिक्रिया बॉडी एक डिक्शनरी है। यह `main.py` में परिभाषित `read_item` फ़ंक्शन का रिटर्न है। आप अनुरोध url `http://127.0.0.1:8000/items/1?q=orange` भी देख सकते हैं। `1` और `orange` हमारे API के इनपुट थे।
FastAPI में एक वैकल्पिक इंटरैक्टिव स्वचालित डॉक्यूमेंटेशन भी उपलब्ध है। उसे देखने के लिए http://127.0.0.1:8000/redoc` पर जाएँ। यह कुछ इस तरह दिखता है:
Image by Author
कुछ उन्नत उदाहरण
API बनाते समय, "path" अनुरोध के रूट या एंडपॉइंट को परिभाषित करता है। हालाँकि, यहाँ हमें एक और चुनाव करना होता है, यानी “ऑपरेशन।” यहाँ `operation` शब्द HTTP "methods" में से किसी एक को संदर्भित करता है। इन तथाकथित "methods" में से एक (या अधिक) का उपयोग करके, आप HTTP प्रोटोकॉल द्वारा समर्थित कई पाथ्स में से प्रत्येक से संवाद कर सकते हैं। आमतौर पर, आप उपयोग करेंगे:
- POST: डेटा बनाने के लिए।
- GET: डेटा पढ़ने के लिए।
- PUT: डेटा अपडेट करने के लिए।
- DELETE: डेटा हटाने के लिए।
- और कुछ अन्य उन्नत मेथड्स
FastAPI सभी HTTP मेथड्स को सपोर्ट करता है।
यह तथ्य कि FastAPI Python टाइप हिंट्स पर बनाया गया है, इस फ़्रेमवर्क का एक और महत्वपूर्ण पहलू है। टाइप हिंट्स Python 3.6 और उसके बाद के संस्करणों में समर्थित हैं। टाइप हिंट्स एक विशेष प्रकार का सिंटैक्स है जिससे आप किसी वेरिएबल के प्रकार की घोषणा कर सकते हैं।
वेरिएबल्स के प्रकार घोषित करने से एडिटर्स और अन्य टूल्स आपको बेहतर सहायता प्रदान कर पाते हैं। आइए एक उन्नत उदाहरण देखते हैं।
हम अपने `main.py` फ़ाइल को संशोधित करेंगे ताकि उसमें एक नया `PUT` अनुरोध शामिल हो जो अलग-अलग डेटा प्रकारों के कई इनपुट लेगा।
```
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
price: float
is_offer: Union[bool, None] = None
@app.get("")
def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
return {"item_name": item.name, "item_id": item_id}
```(उदाहरण मूल दस्तावेज़ से पुन: प्रस्तुत)। @tiangolo को धन्यवाद।
परिवर्तन:
एक `put` अनुरोध जोड़ा गया है जो दो इनपुट लेता है। `item_id` एक integer है और `item` प्रकार कस्टम क्लास `Item` की ओर इशारा करता है, जो `pydantic` के `BaseModel` से इनहेरिट करता है। क्लास `Item` में तीन एट्रिब्यूट हैं: `name`, `price`, `is_offer`, और इन सभी के डेटा प्रकार अलग-अलग हैं।
FastAPI यह जाँच करेगा:
- `name` एक `str` है।
- `price` एक `float` है।
- यदि उपस्थित हो, तो `is_offer` एक bool है।
टाइप हिंट्स का लाभ यह है कि आप एक बार मानक Python (3.6+) में फ़ंक्शन पैरामीटर्स के रूप में पैरामीटर्स, बॉडी आदि के प्रकार घोषित कर देते हैं। आपको मिलेगा:
- एडिटर सपोर्ट, जिसमें ऑटो-कम्प्लीशन, टाइप चेक्स शामिल हैं
- डेटा वैलिडेशन
- इनपुट डेटा का रूपांतरण
- आउटपुट डेटा का रूपांतरण
- समझने में आसान त्रुटियाँ
Django और Flask की तुलना में FastAPI
ये तीनों फ़्रेमवर्क Python वेब फ़्रेमवर्क हैं जिनका उपयोग आप वेब ऐप्लिकेशन विकसित करने के लिए कर सकते हैं। प्रत्येक के अपने-अपने फायदे और सीमाएँ हैं।
Django एक फुल-फ़ीचर्ड फ़्रेमवर्क है जो शुरुआत के लिए हर चीज़ देता है, जिसमें बिल्ट-इन ORM और एडमिन पैनल शामिल हैं। शुरुआती लोगों के लिए यह थोड़ा भारी हो सकता है, लेकिन इसका व्यापक डॉक्यूमेंटेशन सीखने को आसान बनाता है।
Flask एक माइक्रोफ़्रेमवर्क है जो हल्का है और शुरुआत करना आसान है। इसमें Django जितनी सुविधाएँ नहीं हैं, लेकिन यह सरल प्रोजेक्ट्स के लिए उपयुक्त है।
FastAPI एक नया फ़्रेमवर्क है जिसे तेज़ और उपयोग में सरल होने के लिए डिज़ाइन किया गया है। इसमें स्वचालित डेटा वैलिडेशन और डॉक्यूमेंटेशन जैसी सुविधाएँ शामिल हैं।
|
Django |
Flask |
FastAPI |
|
|
समुदाय |
बड़ा। 66K GitHub सितारे |
बड़ा। 61K GitHub सितारे |
बड़ा। 50K GitHub सितारे |
|
प्रदर्शन |
Django भारी-भरकम है। प्रदर्शन के लिहाज से यह सर्वश्रेष्ठ नहीं है। |
Flask एक माइक्रो वेब फ़्रेमवर्क है। यह Django से बेहतर प्रदर्शन करता है। |
FastAPI सबसे तेज़ वेब फ़्रेमवर्क में से एक है, जिसमें नैटिव async सपोर्ट है जो फ़्रेमवर्क की दक्षता बढ़ाता है। |
|
Async सपोर्ट |
हाँ, सीमित लेटेंसी के साथ। |
नहीं। Asyncio की आवश्यकता |
FastAPI नैटिव async सपोर्ट प्रदान करता है। |
|
उपयोग में सरलता |
Django बड़ा है और इसलिए सीखने में थोड़ा जटिल। |
Flask सीखने में आसान और उपयोग में काफ़ी सीधा। |
FastAPI इन तीनों में सबसे सरल है। |
|
इंटरैक्टिव डॉक्यूमेंटेशन |
इंटरैक्टिव नहीं |
नहीं |
हाँ (OpenAI, Redoc) |
|
डेटा वेरिफ़िकेशन |
नहीं |
नहीं |
हाँ |
FastAPI प्रदर्शन बेंचमार्क
techempower द्वारा चलाए गए परीक्षणों के परिणामों के अनुसार, समग्र प्रदर्शन के मामले में FastAPI अन्य सभी फ़्रेमवर्क से बेहतर है।
Source: https://www.techempower.com/benchmarks/
उदाहरण: PyCaret के साथ एंड-टू-एंड मशीन लर्निंग पाइपलाइन बनाना और FastAPI से डिप्लॉय करना
इस खंड में, हम जल्दी से एक मशीन लर्निंग पाइपलाइन बनाएँगे और फिर मॉडल को सर्व करने के लिए एक API बनाएँगे। हम लो-कोड Python लाइब्रेरी PyCaret का उपयोग पाइपलाइन बनाने और API बनाने के लिए करेंगे। PyCaret की FastAPI के साथ एकीकरण है, जो मशीन लर्निंग मॉडलों को API के रूप में बनाना और सर्व करना अत्यंत सरल बना देता है।
PyCaret
PyCaret Python में एक ओपन-सोर्स, लो-कोड मशीन लर्निंग लाइब्रेरी है जो मशीन लर्निंग वर्कफ़्लो को स्वचालित करती है। यह एक एंड-टू-एंड मशीन लर्निंग और मॉडल मैनेजमेंट टूल है जो प्रयोग चक्र को कई गुना तेज़ करता है और आपकी उत्पादकता बढ़ाता है।
```
pip install pycaret
```
```
import pycaret
pycaret.__version__
>>> 2.3.10
```हम इस उदाहरण में `insurance` डेटासेट का उपयोग करेंगे। यह एक रिग्रेशन उपयोग-मामला है जिसमें उम्र, लिंग, BMI और क्षेत्र के आधार पर मेडिकल चार्जेज़ का पूर्वानुमान लगाया जाता है।
```
from pycaret.datasets import get_data
data = get_data(‘insurance’)
```
Image by Author
अगले चरण में हम pycaret की `setup` फ़ंक्शन को इनिशियलाइज़ करेंगे। यह फ़ंक्शन PyCaret में प्रयोग को इनिशियलाइज़ करता है और फ़ंक्शन में दिए गए सभी पैरामीटर्स के आधार पर ट्रांसफ़ॉर्मेशन पाइपलाइन बनाता है।
`setup` को किसी भी अन्य फ़ंक्शन से पहले चलाया जाना चाहिए। इसे काम करने के लिए दो पैरामीटर चाहिए: `data` और `target`। `setup` में शेष सभी आर्ग्युमेंट वैकल्पिक हैं। `setup` फ़ंक्शन डेटा प्रीप्रोसेसिंग की संपूर्ण प्रक्रियाओं को नियंत्रित करने के लिए ज़िम्मेदार है। PyCaret में समर्थित सभी प्रीप्रोसेसिंग प्रक्रियाओं की विस्तृत सूची के लिए PyCaret दस्तावेज़ देखें।
```
from pycaret.regression import *
s = setup(data, target = 'charges')
```
Image by Author Output truncated.
सेटअप पूरा होते ही, हम सिर्फ एक लाइन कोड से मॉडल ट्रेनिंग और चयन शुरू कर सकते हैं: `compare_models`। यह फ़ंक्शन क्रॉस-वैलिडेशन का उपयोग करके मॉडल लाइब्रेरी के भीतर सभी एस्टीमेटर्स के प्रदर्शन को ट्रेन और इवैल्यूएट करता है। इस फ़ंक्शन का परिणाम एक स्कोरिंग ग्रिड होता है जिसमें क्रॉस-वैलिडेशन से प्राप्त औसत स्कोर शामिल होते हैं।
```
best = compare_models()
```
Image by Author
इसके आधार पर सबसे अच्छा प्रदर्शन करने वाला मॉडल `Gradient Boosting Regressor` है। चाहें तो हम विज़ुअलाइज़ेशन के माध्यम से मॉडल का विश्लेषण कर सकते हैं और हाइपरपैरामीटर ट्यूनिंग या मॉडल एन्सेम्बलिंग द्वारा प्रदर्शन को और बेहतर करने की कोशिश कर सकते हैं, लेकिन इस ट्यूटोरियल में हम ऐसा नहीं करेंगे।
हम सीधे FastAPI का उपयोग करके प्रोडक्शन में प्रेडिक्शंस सर्व करने के लिए सर्वश्रेष्ठ मॉडल का API बनाने पर जाएँगे। ध्यान रखें, PyCaret का FastAPI के साथ एकीकरण है, इसलिए यह `create_api` फ़ंक्शन का उपयोग करके मॉडल से स्वतः REST API बना सकता है।
```
create_api (best, 'insurance_prediction_model')
```
अब इस API को चलाने के लिए, कमांड प्रॉम्प्ट टर्मिनल खोलें और उस फ़ोल्डर में जाएँ जहाँ आपका Notebook है और निम्न कमांड चलाएँ: `python insurance_prediction_model.py`।
`http://127.0.0.1:8000/docs` पर जाएँ और आपको वही UI दिखाई देगा जो आपने इस ट्यूटोरियल में पहले देखा था
Image by Author
Image by Author
आप वैकल्पिक इंटरैक्टिव डॉक्यूमेंटेशन भी `http://127.0.0.1:8000/redoc` पर जाकर देख सकते हैं
Image by Author
ध्यान रखें, डिफ़ॉल्ट और redoc दोनों इंटरैक्टिव डॉक्यूमेंटेशन OpenAPI मानकों से संचालित होते हैं।
यदि आप वह फ़ाइल देखना चाहते हैं जो PyCaret ने `create_api` फ़ंक्शन का उपयोग करते समय बनाई थी, तो आप उसे अपने Notebook वाले फ़ोल्डर में देख सकते हैं। यह कुछ इस तरह दिखती है:
```
import pandas as pd
from pycaret.regression import load_model, predict_model
from fastapi import FastAPI
import uvicorn
# Create the app
app = FastAPI()
# Load trained Pipeline
model = load_model('my_lr_api')
# Define predict function
@app.post('/predict')
def predict(age, sex, bmi, children, smoker, region):
data = pd.DataFrame([[age, sex, bmi, children, smoker, region]])
data.columns = ['age', 'sex', 'bmi', 'children', 'smoker', 'region']
predictions = predict_model(model, data=data)
return {'prediction': list(predictions['Label'])}
if __name__ == '__main__':
uvicorn.run(app, host='127.0.0.1', port=8000)
```निष्कर्ष
इस लेख में API की अवधारणा और उनके उपयोग के कारणों पर चर्चा की गई। आधुनिक आर्किटेक्चर में API महत्वपूर्ण हैं क्योंकि वे अलग-अलग सॉफ़्टवेयर प्रोग्रामों को डेटा और कार्यक्षमता साझा करने देती हैं। इससे अधिक विश्वसनीय और रखरखाव में आसान जटिल प्रणालियाँ बनाना संभव होता है।
इसके बाद हमने Python में एक अपेक्षाकृत नए फ़्रेमवर्क FastAPI पर गहराई से चर्चा की। FastAPI एक नया API फ़्रेमवर्क है जिसे उपयोग में आसान और कुशल बनाने के लिए डिज़ाइन किया गया है। यह उन डेवलपर्स के लिए एक बढ़िया विकल्प है जो तेज़ी और आसानी से API बनाना चाहते हैं।
GitHub स्टार इतिहास - star-history.com द्वारा बनाया गया
यदि आप Flask का उपयोग करके Python में मशीन लर्निंग मॉडल से एक सरल API बनाना भी सीखना चाहते हैं, तो यह आसान-से-समझने वाला Turning Machine Learning Models into APIs in Python ट्यूटोरियल देखें।
क्या FastAPI असिंक्रोनस है?
क्या FastAPI प्रोडक्शन के लिए तैयार है?
FastAPI, Flask से कैसे अलग है?
क्या FastAPI में बिल्ट-इन डेवलपमेंट सर्वर भी होता है?
क्या FastAPI Python 2 पर समर्थित है?
क्या FastAPI केवल Python में ही उपलब्ध है?
क्या FastAPI, Go प्रोग्रामिंग भाषा से तेज़ है?
क्या FastAPI Pydantic के साथ संगत है?
विषय