FastAPI का उपयोग करके उच्च-प्रदर्शन, उत्पादन-तैयार LLM API का निर्माण: एक चरण-दर-चरण मार्गदर्शिका

FastAPI, एक आधुनिक, उच्च-प्रदर्शन वाला Python वेब फ्रेमवर्क, अपनी उपयोग में आसानी, गति और स्वचालित रूप से उत्पन्न API दस्तावेज़ों के लिए लोकप्रिय है। विशेष रूप से LLM (Large Language Model) अनुप्रयोगों के लिए बैकएंड API के निर्माण में, FastAPI एक मजबूत लाभ प्रदर्शित करता है। यह लेख आपको चरण-दर-चरण सिखाएगा कि FastAPI का उपयोग करके उत्पादन-तैयार LLM API कैसे बनाया जाए, और कुछ सर्वोत्तम प्रथाओं का पता लगाएगा।

FastAPI क्यों चुनें?

LLM अनुप्रयोगों के लिए API बनाते समय, FastAPI निम्नलिखित महत्वपूर्ण लाभ प्रदान करता है:

• उच्च प्रदर्शन: ASGI पर आधारित, FastAPI उच्च समवर्ती अनुरोधों को संभाल सकता है, जो त्वरित प्रतिक्रिया की आवश्यकता वाले LLM अनुप्रयोगों के लिए महत्वपूर्ण है।
• अतुल्यकालिक समर्थन: FastAPI में async और await कीवर्ड के लिए अंतर्निहित समर्थन है, जो अतुल्यकालिक संचालन को आसानी से संभाल सकता है, जैसे LLM अनुमान को कॉल करना, मुख्य थ्रेड को अवरुद्ध करने से बचना।
• स्वचालित API दस्तावेज़: FastAPI OpenAPI और JSON Schema का उपयोग करके इंटरैक्टिव API दस्तावेज़ (Swagger UI) स्वचालित रूप से उत्पन्न करता है, जिससे डेवलपर्स को आपके API का परीक्षण और उपयोग करने में आसानी होती है।
• डेटा सत्यापन: FastAPI अनुरोध मापदंडों की शुद्धता सुनिश्चित करने और त्रुटियों को कम करने के लिए Pydantic का उपयोग करके डेटा सत्यापन करता है।
• निर्भरता इंजेक्शन: FastAPI की निर्भरता इंजेक्शन प्रणाली LLM मॉडल जैसे संसाधनों को प्रबंधित और साझा करना आसान बनाती है।
• सक्रिय समुदाय: FastAPI का एक बड़ा और सक्रिय समुदाय है, जिससे भरपूर संसाधन और समर्थन प्राप्त किया जा सकता है।

तैयारी

1. Python स्थापित करें: सुनिश्चित करें कि आपने Python 3.7 या उच्चतर संस्करण स्थापित किया है।

2. FastAPI और Uvicorn स्थापित करें: pip का उपयोग करके FastAPI और Uvicorn (ASGI सर्वर) स्थापित करें:

   pip install fastapi uvicorn
   

3. LLM मॉडल चुनें: वह LLM मॉडल चुनें जिसका आप उपयोग करना चाहते हैं। यह OpenAI का मॉडल हो सकता है, या TinyLlama जैसे ओपन-सोर्स मॉडल हो सकता है। यदि आप OpenAI चुनते हैं, तो आपको OpenAI API कुंजी प्राप्त करने की आवश्यकता है। यदि आप TinyLlama चुनते हैं, तो आपको मॉडल फ़ाइल डाउनलोड करने की आवश्यकता है।

चरण 1: FastAPI एप्लिकेशन बनाएं

main.py नामक एक फ़ाइल बनाएँ और निम्नलिखित कोड जोड़ें:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="LLM के साथ इंटरैक्ट करने के लिए एक सरल API।")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

यह कोड एक FastAPI एप्लिकेशन को परिभाषित करता है, और दो Pydantic मॉडल को परिभाषित करता है: InputText का उपयोग इनपुट टेक्स्ट प्राप्त करने के लिए किया जाता है, और OutputText का उपयोग उत्पन्न टेक्स्ट वापस करने के लिए किया जाता है।

चरण 2: LLM अनुमान तर्क जोड़ें

आपके द्वारा चुने गए LLM मॉडल के अनुसार, संबंधित अनुमान तर्क जोड़ें। यहां OpenAI API का उपयोग करने का एक उदाहरण दिया गया है:

import openai
import os

# OpenAI API कुंजी प्राप्त करें
openai.api_key = os.environ.get("OPENAI_API_KEY")  # पर्यावरण चर का उपयोग करने की अनुशंसा की जाती है
```@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generates text based on the input text using OpenAI.
    """
    try:
        response = openai.Completion.create(
            engine="text-davinci-003", # मॉडल चुनें
            prompt=input_text.text,
            max_tokens=150,
            n=1,
            stop=None,
            temperature=0.7,
        )
        generated_text = response.choices[0].text.strip()
        return OutputText(generated_text=generated_text)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

यह कोड एक /generate रूट को परिभाषित करता है, जो इनपुट के रूप में एक InputText ऑब्जेक्ट प्राप्त करता है, OpenAI API को टेक्स्ट उत्पन्न करने के लिए कॉल करता है, और उत्पन्न टेक्स्ट को OutputText ऑब्जेक्ट के रूप में लौटाता है। text-davinci-003 को अपने चुने हुए उपयुक्त मॉडल से बदलना याद रखें।

यदि आप TinyLlama जैसे स्थानीय मॉडल का उपयोग करते हैं, तो आपको transformers जैसे संबंधित पुस्तकालयों को स्थापित करने और मॉडल को मेमोरी में लोड करने की आवश्यकता है। कोड उदाहरण इस प्रकार है:

from transformers import pipeline
import torch

generator = pipeline('text-generation', model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", torch_dtype=torch.bfloat16, device_map="auto")

@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generates text based on the input text using TinyLlama.
    """
    try:
        generated_text = generator(input_text.text, max_length=50, do_sample=True, temperature=0.7)[0]['generated_text']
        return OutputText(generated_text=generated_text)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

चरण 3: FastAPI एप्लिकेशन चलाएँ

Uvicorn का उपयोग करके FastAPI एप्लिकेशन चलाएँ:

uvicorn main:app --reload
```यह एक लोकल सर्वर शुरू करेगा, जिसे आप ब्राउज़र में `http://127.0.0.1:8000/docs` पर जाकर ऑटो-जेनरेटेड एपीआई डॉक्यूमेंटेशन देखने के लिए एक्सेस कर सकते हैं। `--reload` पैरामीटर कोड में बदलाव के बाद सर्वर को ऑटोमैटिकली रीस्टार्ट कर सकता है, जिससे डेवलपमेंट आसान हो जाता है।

## स्टेप 4: एपीआई का परीक्षण

एपीआई डॉक्यूमेंटेशन या कर्ल जैसे टूल का उपयोग करके अपनी एपीआई का परीक्षण करें। उदाहरण के लिए, कर्ल का उपयोग करके एक POST अनुरोध भेजें:

```bash
curl -X POST -H "Content-Type: application/json" -d '{"text": "Tell me a joke about cats."}' http://127.0.0.1:8000/generate

आपको जेनरेटेड टेक्स्ट वाला एक JSON रिस्पॉन्स मिलना चाहिए।

स्टेप 5: प्रोडक्शन डिप्लॉयमेंट

फास्टएपीआई एप्लिकेशन को प्रोडक्शन एनवायरनमेंट में डिप्लॉय करें, उदाहरण के लिए:

• Docker: अपने एप्लिकेशन को कंटेनराइज़ करने के लिए Docker का उपयोग करें, जिससे डिप्लॉयमेंट और मैनेजमेंट आसान हो जाता है।
• क्लाउड प्लेटफॉर्म: क्लाउड प्लेटफॉर्म पर डिप्लॉय करें, जैसे AWS, Google Cloud Platform या Azure। लेख में उल्लिखित Azure Cosmos DB और Azure Functions का उपयोग सर्वरलेस एपीआई बनाने के लिए किया जा सकता है। Modal का उपयोग ऑटो-स्केलिंग फास्टएपीआई एप्लिकेशन को डिप्लॉय करने के लिए भी किया जा सकता है।
• सर्वर: अपने खुद के सर्वर पर डिप्लॉय करें।

सर्वश्रेष्ठ अभ्यास

• संवेदनशील जानकारी संग्रहीत करने के लिए पर्यावरण चर का उपयोग करें: एपीआई कुंजी जैसी संवेदनशील जानकारी को कोड में हार्डकोड न करें, बल्कि पर्यावरण चर का उपयोग करें।
• लॉगिंग जोड़ें: डिबगिंग और निगरानी को आसान बनाने के लिए एपीआई की रनिंग स्थिति को रिकॉर्ड करने के लिए लॉगिंग मॉड्यूल का उपयोग करें।
• त्रुटि हैंडलिंग जोड़ें: संभावित अपवादों को संभालने के लिए try...except ब्लॉक का उपयोग करें और उचित त्रुटि संदेश लौटाएं।
• दर सीमा: एपीआई के दुरुपयोग को रोकने के लिए दर सीमक का उपयोग करें। फास्टएपीआई में कुछ रेडीमेड दर सीमा लाइब्रेरी उपलब्ध हैं।
• कैशिंग: दोहराए जाने वाले अनुरोधों के लिए, प्रदर्शन को बेहतर बनाने के लिए कैशिंग का उपयोग किया जा सकता है।
• निगरानी: एपीआई के प्रदर्शन और उपलब्धता की निगरानी के लिए निगरानी टूल का उपयोग करें।

उन्नत तकनीकें

• असिंक्रोनस प्रोसेसिंग: समय लेने वाली एलएलएम अनुमान के लिए, मुख्य थ्रेड को ब्लॉक करने से बचने के लिए async और await कीवर्ड का उपयोग करके एसिंक्रोनस प्रोसेसिंग का उपयोग करें।
• स्ट्रीमिंग रिस्पॉन्स: स्ट्रीमिंग रिस्पॉन्स (StreamingResponse) का उपयोग करके जेनरेटेड टेक्स्ट को रीयल टाइम में लौटाया जा सकता है, जिससे उपयोगकर्ता अनुभव बेहतर होता है।
• मल्टी-थ्रेडिंग/मल्टी-प्रोसेसिंग: सीपीयू गहन एलएलएम अनुमान के लिए, प्रदर्शन को बेहतर बनाने के लिए मल्टी-थ्रेडिंग या मल्टी-प्रोसेसिंग का उपयोग किया जा सकता है।
• जीपीयू एक्सेलरेशन: यदि आपका एलएलएम मॉडल जीपीयू एक्सेलरेशन का समर्थन करता है, तो अनुमान गति को बेहतर बनाने के लिए CUDA या अन्य जीपीयू एक्सेलरेशन लाइब्रेरी का उपयोग किया जा सकता है।

निष्कर्षFastAPI एक उच्च-प्रदर्शन, उत्पादन-तैयार LLM API बनाने के लिए एक शक्तिशाली उपकरण है। इस लेख में दिए गए मार्गदर्शन के माध्यम से, आप जल्दी से एक LLM API स्थापित कर सकते हैं, और इसे अपनी आवश्यकताओं के अनुसार विस्तारित और अनुकूलित कर सकते हैं। याद रखें, निरंतर सीखना और अभ्यास एक उत्कृष्ट LLM एप्लिकेशन डेवलपर बनने की कुंजी है। लेख में उल्लिखित Hornbeam भी एक ध्यान देने योग्य ASGI सर्वर है, जो Gunicorn से तेज़ और अधिक स्थिर होने का दावा करता है, और इसका उपयोग FastAPI एप्लिकेशन को तैनात करने के लिए किया जा सकता है।