Používanie FastAPI na vytvorenie vysoko výkonného LLM API pripraveného na produkciu: Podrobný návod

FastAPI, ako moderný, vysoko výkonný Python Web framework, je populárny pre svoju jednoduchosť použitia, rýchlosť a automaticky generovanú API dokumentáciu. Obzvlášť pri vytváraní backend API pre LLM (Large Language Model) aplikácie, FastAPI preukazuje silné výhody. Tento článok vás krok za krokom naučí, ako používať FastAPI na vytvorenie LLM API pripraveného na produkciu a preskúma niektoré osvedčené postupy.

Prečo si vybrať FastAPI?

Pri vytváraní API pre LLM aplikácie ponúka FastAPI nasledujúce kľúčové výhody:

• Vysoký výkon: Na základe ASGI dokáže FastAPI spracovať vysoko súbežné požiadavky, čo je kľúčové pre LLM aplikácie, ktoré vyžadujú rýchlu odozvu.
• Asynchrónna podpora: FastAPI má zabudovanú podporu pre kľúčové slová async a await, čo uľahčuje spracovanie asynchrónnych operácií, ako je volanie LLM inferencie, a vyhýba sa blokovaniu hlavného vlákna.
• Automatická API dokumentácia: FastAPI používa OpenAPI a JSON Schema na automatické generovanie interaktívnej API dokumentácie (Swagger UI), čo vývojárom uľahčuje testovanie a používanie vášho API.
• Validácia dát: FastAPI používa Pydantic na validáciu dát, čím zabezpečuje správnosť parametrov požiadaviek a znižuje chyby.
• Injekcia závislostí: Systém injekcie závislostí FastAPI uľahčuje správu a zdieľanie zdrojov, ako sú LLM modely.
• Aktívna komunita: FastAPI má rozsiahlu a aktívnu komunitu, ktorá poskytuje bohaté zdroje a podporu.

Príprava

1. Inštalácia Pythonu: Uistite sa, že máte nainštalovaný Python 3.7 alebo novší.

2. Inštalácia FastAPI a Uvicorn: Použite pip na inštaláciu FastAPI a Uvicorn (ASGI server):

   pip install fastapi uvicorn
   

3. Výber LLM modelu: Vyberte LLM model, ktorý chcete použiť. Môže to byť model od OpenAI, alebo open-source model, napríklad TinyLlama. Ak si vyberiete OpenAI, budete potrebovať získať OpenAI API kľúč. Ak si vyberiete TinyLlama, budete si musieť stiahnuť súbor s modelom.

Krok 1: Vytvorenie FastAPI aplikácie

Vytvorte súbor s názvom main.py a pridajte nasledujúci kód:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="A simple API for interacting with LLMs.")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

Tento kód definuje FastAPI aplikáciu a definuje dva Pydantic modely: InputText na prijímanie vstupného textu a OutputText na vrátenie generovaného textu.

Krok 2: Pridanie LLM inferenčnej logiky

Pridajte príslušnú inferenčnú logiku podľa LLM modelu, ktorý ste si vybrali. Tu je príklad použitia OpenAI API:

import openai
import os

# Získanie OpenAI API kľúča
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Odporúča sa používať premenné prostredia
```@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", # Vyberte model
            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))

Tento kód definuje trasu /generate, ktorá prijíma objekt InputText ako vstup, volá OpenAI API na generovanie textu a vracia vygenerovaný text ako objekt OutputText. Nezabudnite nahradiť text-davinci-003 vhodným modelom podľa vášho výberu.

Ak používate lokálne modely, ako napríklad TinyLlama, musíte nainštalovať príslušné knižnice, napríklad transformers, a načítať model do pamäte. Príklad kódu:

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))

Krok 3: Spustenie aplikácie FastAPI

Spustite aplikáciu FastAPI pomocou Uvicorn:

uvicorn main:app --reload
```Týmto sa spustí lokálny server a v prehliadači môžete navštíviť adresu `http://127.0.0.1:8000/docs` a zobraziť automaticky generovanú dokumentáciu API. Parameter `--reload` umožňuje automatické reštartovanie servera po úprave kódu, čo uľahčuje vývoj.

## Krok 4: Testovanie API

Na testovanie API použite dokumentáciu API alebo nástroje ako curl. Napríklad, pomocou curl odošlite požiadavku 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

Mali by ste dostať JSON odpoveď obsahujúcu vygenerovaný text.

Krok 5: Nasadenie do produkcie

Aplikáciu FastAPI nasaďte do produkčného prostredia, napríklad:

• Docker: Použite Docker na kontajnerizáciu vašej aplikácie, čo uľahčuje nasadenie a správu.
• Cloudová platforma: Nasaďte na cloudovú platformu, ako napríklad AWS, Google Cloud Platform alebo Azure. Azure Cosmos DB a Azure Functions, ktoré sú spomenuté v texte, sa dajú použiť na vytvorenie serverless API. Modal sa dá použiť aj na nasadenie automaticky škálovateľných aplikácií FastAPI.
• Server: Nasaďte na vlastný server.

Osvedčené postupy

• Používajte premenné prostredia na ukladanie citlivých informácií: Netvrdo kódujte citlivé informácie, ako sú API kľúče, do kódu, ale namiesto toho používajte premenné prostredia.
• Pridajte protokolovanie: Používajte modul protokolovania na zaznamenávanie prevádzkového stavu API, čo uľahčuje ladenie a monitorovanie.
• Pridajte spracovanie chýb: Používajte bloky try...except na spracovanie možných výnimiek a vráťte vhodné chybové hlásenia.
• Obmedzenie rýchlosti: Používajte obmedzovač rýchlosti na zabránenie zneužitiu API. FastAPI má k dispozícii niekoľko hotových knižníc na obmedzenie rýchlosti.
• Ukladanie do vyrovnávacej pamäte (cache): Pre opakované požiadavky môžete použiť ukladanie do vyrovnávacej pamäte na zvýšenie výkonu.
• Monitorovanie: Používajte nástroje na monitorovanie výkonu a dostupnosti API.

Pokročilé techniky

• Asynchrónne spracovanie: Pre časovo náročné LLM odvodzovanie používajte kľúčové slová async a await na asynchrónne spracovanie, aby ste predišli blokovaniu hlavného vlákna.
• Streamované odpovede: Používanie streamovaných odpovedí (StreamingResponse) umožňuje vrátiť vygenerovaný text v reálnom čase, čím sa zlepší používateľská skúsenosť.
• Multithreading/Multiprocessing: Pre LLM odvodzovanie náročné na CPU môžete použiť multithreading alebo multiprocessing na zvýšenie výkonu.
• GPU akcelerácia: Ak váš LLM model podporuje GPU akceleráciu, môžete použiť CUDA alebo iné GPU akceleračné knižnice na zvýšenie rýchlosti odvodzovania.

ZáverFastAPI je výkonný nástroj na vytváranie vysokovýkonných LLM API pripravených na produkciu. Prostredníctvom tohto sprievodcu môžete rýchlo vytvoriť LLM API a rozšíriť a optimalizovať ho podľa svojich potrieb. Pamätajte, že neustále učenie a prax sú kľúčom k tomu, aby ste sa stali vynikajúcim vývojárom aplikácií LLM. Hornbeam, ktorý je spomenutý v článku, je tiež ASGI server, ktorý stojí za pozornosť a tvrdí, že je rýchlejší a stabilnejší ako Gunicorn a dá sa použiť na nasadenie aplikácií FastAPI.