FastAPI ஐப் பயன்படுத்தி உயர் செயல்திறன், உற்பத்திக்குத் தயாரான LLM API ஐ உருவாக்குதல்: படிப்படியான வழிகாட்டி

FastAPI, ஒரு நவீன, உயர் செயல்திறன் கொண்ட பைதான் வலை கட்டமைப்பு, அதன் பயன்பாட்டின் எளிமை, வேகம் மற்றும் தானாக உருவாக்கப்பட்ட 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. பைத்தானை நிறுவுதல்: நீங்கள் பைதான் 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` என்ற முகவரியில் பிரவுசரில் சென்று தானாக உருவாக்கப்பட்ட API ஆவணத்தைப் பார்க்கலாம். `--reload` அளவுரு, கோட் மாற்றங்களுக்குப் பிறகு சர்வரை தானாகவே மறுதொடக்கம் செய்ய உதவுகிறது, இது டெவலப்மென்ட்க்கு வசதியானது.

## படி 4: API-ஐ சோதித்தல்

API ஆவணம் அல்லது curl போன்ற கருவிகளைப் பயன்படுத்தி உங்கள் API-ஐ சோதிக்கவும். உதாரணமாக, curl ஐப் பயன்படுத்தி ஒரு 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: உற்பத்திக்கு அனுப்புதல்

FastAPI பயன்பாட்டை உற்பத்திச் சூழலுக்கு அனுப்பவும், உதாரணமாக:

• Docker: உங்கள் பயன்பாட்டை Docker கன்டெய்னராக மாற்றுங்கள், இது அனுப்புவதற்கும் நிர்வகிப்பதற்கும் வசதியானது.
• கிளவுட் தளம்: AWS, Google Cloud Platform அல்லது Azure போன்ற கிளவுட் தளத்தில் அனுப்பவும். கட்டுரையில் குறிப்பிடப்பட்டுள்ள Azure Cosmos DB மற்றும் Azure Functions ஆகியவை சர்வர்லெஸ் API-ஐ உருவாக்கப் பயன்படும். தானாக விரிவாக்கக்கூடிய FastAPI பயன்பாட்டை அனுப்ப Modal ஐயும் பயன்படுத்தலாம்.
• சர்வர்: உங்கள் சொந்த சர்வரில் அனுப்பவும்.

சிறந்த நடைமுறைகள்

• சுற்றுச்சூழல் மாறிகளைப் பயன்படுத்தி முக்கியமான தகவல்களைச் சேமிக்கவும்: API விசைகள் போன்ற முக்கியமான தகவல்களை கோட்-இல் ஹார்ட்கோட் செய்ய வேண்டாம், அதற்குப் பதிலாக சுற்றுச்சூழல் மாறிகளைப் பயன்படுத்தவும்.
• பதிவுகளைச் சேர்த்தல்: API-இன் இயக்க நிலையைப் பதிவு செய்ய லாக்கிங் தொகுதியைப் பயன்படுத்தவும், இது பிழைத்திருத்தம் மற்றும் கண்காணிப்புக்கு வசதியானது.
• பிழை கையாளுதலைச் சேர்த்தல்: ஏற்படக்கூடிய விதிவிலக்குகளைக் கையாள try...except தொகுதியைப் பயன்படுத்தவும், மேலும் பொருத்தமான பிழைத் தகவலைத் திருப்பி அனுப்பவும்.
• வேக வரம்பு: API தவறாகப் பயன்படுத்தப்படுவதைத் தடுக்க வேக வரம்பைப் பயன்படுத்தவும். FastAPI-இல் சில ஆயத்த வேக வரம்பு லைப்ரரிகள் உள்ளன.
• கேச்சிங்: மீண்டும் மீண்டும் வரும் கோரிக்கைகளுக்கு, செயல்திறனை மேம்படுத்த கேச்சிங்கைப் பயன்படுத்தலாம்.
• கண்காணிப்பு: API-இன் செயல்திறன் மற்றும் கிடைக்கும் தன்மையைக் கண்காணிக்க கண்காணிப்பு கருவிகளைப் பயன்படுத்தவும்.

மேம்பட்ட தந்திரங்கள்

• ஒத்திசைவற்ற செயலாக்கம்: அதிக நேரம் எடுக்கும் LLM அனுமானத்திற்கு, async மற்றும் await முக்கிய வார்த்தைகளைப் பயன்படுத்தி ஒத்திசைவற்ற செயலாக்கத்தைச் செய்து, பிரதான த்ரெட் தடுக்கப்படுவதைத் தவிர்க்கவும்.
• ஸ்ட்ரீமிங் ரெஸ்பான்ஸ்: ஸ்ட்ரீமிங் ரெஸ்பான்ஸ் (StreamingResponse) ஐப் பயன்படுத்தி உருவாக்கப்பட்ட உரையை நிகழ்நேரத்தில் திருப்பி அனுப்பலாம், இது பயனர் அனுபவத்தை மேம்படுத்துகிறது.
• மல்டி-த்ரெடிங்/மல்டி-பிராசஸிங்: CPU தீவிரமான LLM அனுமானத்திற்கு, செயல்திறனை மேம்படுத்த மல்டி-த்ரெடிங் அல்லது மல்டி-பிராசஸிங்கைப் பயன்படுத்தலாம்.
• GPU முடுக்கம்: உங்கள் LLM மாடல் GPU முடுக்கத்தை ஆதரித்தால், அனுமான வேகத்தை அதிகரிக்க CUDA அல்லது பிற GPU முடுக்க லைப்ரரிகளைப் பயன்படுத்தலாம்.

முடிவுரைFastAPI என்பது உயர் செயல்திறன் மற்றும் உற்பத்திக்குத் தயாரான LLM API-களை உருவாக்க உதவும் ஒரு சக்திவாய்ந்த கருவியாகும். இந்தக் கட்டுரையின் வழிகாட்டுதலின் மூலம், நீங்கள் விரைவாக ஒரு LLM API-ஐ அமைத்து, உங்கள் தேவைகளுக்கு ஏற்ப அதை விரிவாக்கலாம் மற்றும் மேம்படுத்தலாம். தொடர்ந்து கற்றுக்கொள்வதும் பயிற்சி செய்வதும் ஒரு சிறந்த LLM பயன்பாட்டு உருவாக்குநராக ஆவதற்கு முக்கியம் என்பதை நினைவில் கொள்ளுங்கள். கட்டுரையில் குறிப்பிடப்பட்டுள்ள Hornbeam ஒரு கவனிக்கத்தக்க ASGI சேவையகம் ஆகும், இது Gunicorn-ஐ விட வேகமாகவும் நிலையானதாகவும் இருப்பதாகக் கூறுகிறது, மேலும் இது FastAPI பயன்பாடுகளைப் பயன்படுத்தப் பயன்படுகிறது.