Nagy teljesítményű, gyártásra kész LLM API létrehozása a FastAPI segítségével: Lépésről lépésre útmutató

A FastAPI, mint egy modern, nagy teljesítményű Python Web keretrendszer, népszerű a könnyű használhatósága, sebessége és automatikusan generált API dokumentációja miatt. Különösen az LLM (Large Language Model) alkalmazások háttér API-jának felépítésében mutatja meg a FastAPI a hatalmas előnyeit. Ez a cikk lépésről lépésre bemutatja, hogyan építhetsz egy gyártásra kész LLM API-t a FastAPI segítségével, és feltár néhány bevált gyakorlatot.

Miért válasszuk a FastAPI-t?

Az LLM alkalmazások API-jának felépítésekor a FastAPI a következő kulcsfontosságú előnyöket kínálja:

• Nagy teljesítmény: Az ASGI-n alapuló FastAPI képes kezelni a nagy konkurens kéréseket, ami elengedhetetlen a gyors válaszokat igénylő LLM alkalmazásokhoz.
• Aszinkron támogatás: A FastAPI beépített támogatást nyújt az async és await kulcsszavakhoz, ami megkönnyíti az aszinkron műveletek kezelését, például az LLM következtetés meghívását, elkerülve a fő szál blokkolását.
• Automatikus API dokumentáció: A FastAPI az OpenAPI és a JSON Schema segítségével automatikusan generál interaktív API dokumentációt (Swagger UI), ami megkönnyíti a fejlesztők számára az API tesztelését és használatát.
• Adatellenőrzés: A FastAPI a Pydantic segítségével végzi az adatellenőrzést, biztosítva a kérés paramétereinek helyességét, csökkentve a hibákat.
• Függőségi injektálás: A FastAPI függőségi injektálási rendszere megkönnyíti az erőforrások, például az LLM modellek kezelését és megosztását.
• Aktív közösség: A FastAPI hatalmas és aktív közösséggel rendelkezik, amelyből bőséges erőforrásokhoz és támogatáshoz juthatsz.

Előkészületek

1. Python telepítése: Győződj meg arról, hogy telepítve van a Python 3.7 vagy újabb verziója.

2. FastAPI és Uvicorn telepítése: Telepítsd a FastAPI-t és az Uvicorn-t (ASGI szerver) a pip segítségével:

   pip install fastapi uvicorn
   

3. LLM modell kiválasztása: Válaszd ki a használni kívánt LLM modellt. Lehet OpenAI modell, vagy nyílt forráskódú modell, például a TinyLlama. Ha az OpenAI-t választod, be kell szerezned egy OpenAI API kulcsot. Ha a TinyLlama-t választod, le kell töltened a modellfájlt.

1. lépés: FastAPI alkalmazás létrehozása

Hozz létre egy main.py nevű fájlt, és add hozzá a következő kódot:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="Egy egyszerű API az LLM-ekkel való interakcióhoz.")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

Ez a kód definiál egy FastAPI alkalmazást, és definiál két Pydantic modellt: az InputText a bemeneti szöveg fogadására, az OutputText a generált szöveg visszaadására szolgál.

2. lépés: LLM következtetési logika hozzáadása

A választott LLM modellnek megfelelően add hozzá a megfelelő következtetési logikát. Itt az OpenAI API használatát vesszük példának:

import openai
import os

# OpenAI API kulcs lekérése
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Javasolt a környezeti változó használata
```@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", # Modell kiválasztása
            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))

Ez a kódrészlet egy /generate útvonalat definiál, amely egy InputText objektumot fogad bemenetként, meghívja az OpenAI API-t szöveg generálására, és a generált szöveget OutputText objektumként adja vissza. Ügyeljen arra, hogy a text-davinci-003-at a választott megfelelő modellre cserélje.

Ha helyi modelleket, például a TinyLlama-t használ, telepítenie kell a megfelelő könyvtárakat, például a transformers-t, és be kell töltenie a modellt a memóriába. A kód példája a következő:

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. lépés: A FastAPI alkalmazás futtatása

A FastAPI alkalmazás futtatása Uvicorn segítségével:

uvicorn main:app --reload
```Ez elindít egy helyi szervert, amelyet a böngészőben a `http://127.0.0.1:8000/docs` címen érhet el az automatikusan generált API dokumentáció megtekintéséhez. A `--reload` paraméter lehetővé teszi a szerver automatikus újraindítását a kód módosítása után, ami megkönnyíti a fejlesztést.

## 4. lépés: API tesztelése

Tesztelje az API-t az API dokumentáció vagy olyan eszközök, mint a curl segítségével. Például küldjön egy POST kérést a curl segítségével:

```bash
curl -X POST -H \A FastAPI egy hatékony eszköz a nagy teljesítményű, éles környezetre kész LLM API-k létrehozásához. Ezen útmutató segítségével gyorsan beállíthatsz egy LLM API-t, és kiterjesztheted és optimalizálhatod az igényeidnek megfelelően. Ne feledd, a folyamatos tanulás és gyakorlás kulcsfontosságú ahhoz, hogy kiváló LLM alkalmazásfejlesztővé válj. A cikkben említett Hornbeam egy figyelemre méltó ASGI szerver is, amely állítólag gyorsabb és stabilabb, mint a Gunicorn, és használható FastAPI alkalmazások telepítésére.