Používání FastAPI k sestavení vysoce výkonného LLM API připraveného pro produkci: Průvodce krok za krokem

FastAPI, jako moderní, vysoce výkonný Python Web framework, je oblíbený pro svou snadnost použití, rychlost a automaticky generovanou API dokumentaci. Zejména při vytváření backend API pro LLM (Large Language Model) aplikace, FastAPI prokazuje silné výhody. Tento článek vás krok za krokem naučí, jak používat FastAPI k sestavení LLM API připraveného pro produkci, a prozkoumá některé osvědčené postupy.

Proč si vybrat FastAPI?

Při vytváření API pro LLM aplikace nabízí FastAPI následující klíčové výhody:

• Vysoký výkon: Díky ASGI dokáže FastAPI zpracovávat vysoce souběžné požadavky, což je zásadní pro LLM aplikace, které vyžadují rychlou odezvu.
• Asynchronní podpora: FastAPI má vestavěnou podporu pro klíčová slova async a await, což usnadňuje zpracování asynchronních operací, jako je volání LLM inference, a zabraňuje blokování hlavního vlákna.
• Automatická API dokumentace: FastAPI používá OpenAPI a JSON Schema k automatickému generování interaktivní API dokumentace (Swagger UI), což vývojářům usnadňuje testování a používání vašeho API.
• Ověřování dat: FastAPI používá Pydantic k ověřování dat, čímž zajišťuje správnost parametrů požadavku a snižuje chyby.
• Vkládání závislostí: Systém vkládání závislostí FastAPI usnadňuje správu a sdílení zdrojů, jako jsou LLM modely.
• Aktivní komunita: FastAPI má velkou a aktivní komunitu, která poskytuje bohaté zdroje a podporu.

Přípravné práce

1. Instalace Pythonu: Ujistěte se, že máte nainstalovaný Python 3.7 nebo novější.

2. Instalace FastAPI a Uvicorn: Pomocí pip nainstalujte FastAPI a Uvicorn (ASGI server):

   pip install fastapi uvicorn
   

3. Výběr LLM modelu: Vyberte LLM model, který chcete použít. Může to být model od OpenAI, nebo open-source model, například TinyLlama. Pokud zvolíte OpenAI, budete potřebovat získat OpenAI API klíč. Pokud zvolíte TinyLlama, budete potřebovat stáhnout soubor modelu.

Krok 1: Vytvoření FastAPI aplikace

Vytvořte soubor s názvem main.py a přidejte následující 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 aplikaci a definuje dva Pydantic modely: InputText pro příjem vstupního textu a OutputText pro vrácení generovaného textu.

Krok 2: Přidání LLM inference logiky

Podle zvoleného LLM modelu přidejte odpovídající inference logiku. Zde je příklad použití OpenAI API:

import openai
import os

# Získání OpenAI API klíče
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Doporučuje se používat proměnné prostředí
```@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, která přijímá objekt InputText jako vstup, volá OpenAI API pro generování textu a vrací vygenerovaný text jako objekt OutputText. Nezapomeňte nahradit text-davinci-003 vhodným modelem dle vašeho výběru.

Pokud používáte lokální model, jako je TinyLlama, je třeba nainstalovat odpovídající knihovnu, například transformers, a načíst model do paměti. Pří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: Spuštění FastAPI aplikace

Spusťte FastAPI aplikaci pomocí Uvicorn:

uvicorn main:app --reload
```Tímto spustíte lokální server a v prohlížeči můžete navštívit `http://127.0.0.1:8000/docs` a zobrazit automaticky generovanou dokumentaci API. Parametr `--reload` umožňuje automatické restartování serveru po úpravě kódu, což usnadňuje vývoj.

## Krok 4: Testování API

Otestujte své API pomocí dokumentace API nebo nástrojů jako curl. Například pomocí curl odešlete požadavek 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

Měli byste obdržet JSON odpověď obsahující vygenerovaný text.

Krok 5: Nasazení do produkce

Nasaďte aplikaci FastAPI do produkčního prostředí, například:

• Docker: Použijte Docker pro kontejnerizaci vaší aplikace, což usnadňuje nasazení a správu.
• Cloudová platforma: Nasaďte na cloudovou platformu, například AWS, Google Cloud Platform nebo Azure. Azure Cosmos DB a Azure Functions, které jsou zmíněny v textu, lze použít k sestavení serverless API. Modal lze také použít k nasazení automaticky škálovatelných aplikací FastAPI.
• Server: Nasaďte na svůj vlastní server.

Osvědčené postupy

• Používejte proměnné prostředí k ukládání citlivých informací: Neukládejte citlivé informace, jako jsou klíče API, přímo do kódu, ale používejte proměnné prostředí.
• Přidejte protokolování: Používejte modul protokolování k zaznamenávání stavu běhu API, což usnadňuje ladění a monitorování.
• Přidejte zpracování chyb: Používejte bloky try...except ke zpracování možných výjimek a vracejte vhodné chybové zprávy.
• Omezení rychlosti: Používejte omezovač rychlosti, abyste zabránili zneužití API. FastAPI má k dispozici několik hotových knihoven pro omezení rychlosti.
• Cache: Pro opakované požadavky můžete použít cache ke zvýšení výkonu.
• Monitorování: Používejte nástroje pro monitorování k monitorování výkonu a dostupnosti API.

Pokročilé tipy

• Asynchronní zpracování: Pro časově náročné odvozování LLM používejte klíčová slova async a await pro asynchronní zpracování, abyste zabránili blokování hlavního vlákna.
• Streamované odpovědi: Použití streamovaných odpovědí (StreamingResponse) umožňuje vracet generovaný text v reálném čase, což zlepšuje uživatelský zážitek.
• Vícevláknové/víceprocesové zpracování: Pro LLM odvozování náročné na CPU můžete použít vícevláknové nebo víceprocesové zpracování ke zvýšení výkonu.
• GPU akcelerace: Pokud váš LLM model podporuje GPU akceleraci, můžete použít CUDA nebo jiné knihovny pro GPU akceleraci ke zvýšení rychlosti odvozování.

ZávěrFastAPI je výkonný nástroj pro vytváření vysoce výkonných, produkčně připravených LLM API. Prostřednictvím tohoto průvodce můžete rychle nastavit LLM API a rozšířit a optimalizovat jej podle svých potřeb. Pamatujte, že neustálé učení a praxe jsou klíčem k tomu, abyste se stali vynikajícím vývojářem LLM aplikací. Hornbeam, zmíněný v článku, je také ASGI server, který stojí za pozornost a tvrdí, že je rychlejší a stabilnější než Gunicorn a lze jej použít k nasazení aplikací FastAPI.