Uporaba FastAPI za izgradnjo visoko zmogljivega LLM API-ja, pripravljenega za produkcijo: Vodnik po korakih

FastAPI, kot sodoben, visoko zmogljiv Python Web framework, je priljubljen zaradi svoje enostavnosti uporabe, hitrosti in samodejno generirane API dokumentacije. Še posebej pri izgradnji zalednih API-jev za LLM (Large Language Model) aplikacije, FastAPI kaže močne prednosti. Ta članek vas bo korak za korakom naučil, kako uporabiti FastAPI za izgradnjo LLM API-ja, pripravljenega za produkcijo, in raziskal nekaj najboljših praks.

Zakaj izbrati FastAPI?

Pri izgradnji API-jev za LLM aplikacije, FastAPI ponuja naslednje ključne prednosti:

• Visoka zmogljivost: Na osnovi ASGI, FastAPI lahko obravnava visoko sočasne zahteve, kar je ključnega pomena za LLM aplikacije, ki zahtevajo hiter odziv.
• Asinhrona podpora: FastAPI ima vgrajeno podporo za ključne besede async in await, kar omogoča enostavno obravnavo asinhronih operacij, kot je klic LLM sklepanja, s čimer se izognemo blokiranju glavne niti.
• Samodejna API dokumentacija: FastAPI uporablja OpenAPI in JSON Schema za samodejno generiranje interaktivne API dokumentacije (Swagger UI), kar razvijalcem olajša testiranje in uporabo vašega API-ja.
• Validacija podatkov: FastAPI uporablja Pydantic za validacijo podatkov, kar zagotavlja pravilnost parametrov zahtev in zmanjšuje napake.
• Vbrizgavanje odvisnosti: Sistem za vbrizgavanje odvisnosti v FastAPI olajša upravljanje in deljenje virov, kot so LLM modeli.
• Aktivna skupnost: FastAPI ima veliko in aktivno skupnost, kjer lahko dobite bogate vire in podporo.

Priprava

1. Namestite Python: Prepričajte se, da imate nameščen Python 3.7 ali novejšo različico.

2. Namestite FastAPI in Uvicorn: Uporabite pip za namestitev FastAPI in Uvicorn (ASGI strežnik):

   pip install fastapi uvicorn
   

3. Izberite LLM model: Izberite LLM model, ki ga želite uporabiti. Lahko je model OpenAI ali odprtokodni model, kot je TinyLlama. Če izberete OpenAI, morate pridobiti ključ API OpenAI. Če izberete TinyLlama, morate prenesti datoteko modela.

Korak 1: Ustvarite FastAPI aplikacijo

Ustvarite datoteko z imenom main.py in dodajte naslednjo kodo:

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

ta koda definira FastAPI aplikacijo in definira dva Pydantic modela: InputText za sprejemanje vhodnega besedila in OutputText za vračanje generiranega besedila.

Korak 2: Dodajte LLM logiko sklepanja

Dodajte ustrezno logiko sklepanja glede na LLM model, ki ste ga izbrali. Tukaj je primer uporabe OpenAI API-ja:

import openai
import os

# Pridobite ključ API OpenAI
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Priporočljivo je uporabljati spremenljivke okolja
```@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", # Izberite 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))

Ta koda definira pot /generate, ki sprejme objekt InputText kot vhod, pokliče OpenAI API za generiranje besedila in vrne generirano besedilo kot objekt OutputText. Upoštevajte, da morate text-davinci-003 zamenjati z ustreznim modelom po vaši izbiri.

Če uporabljate lokalne modele, kot je TinyLlama, morate namestiti ustrezne knjižnice, na primer transformers, in naložiti model v pomnilnik. Primer kode je naslednji:

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. korak: Zagon aplikacije FastAPI

Za zagon aplikacije FastAPI uporabite Uvicorn:

uvicorn main:app --reload
```To bo zagnalo lokalni strežnik, do katerega lahko dostopate v brskalniku na `http://127.0.0.1:8000/docs` za ogled samodejno ustvarjene API dokumentacije. Parameter `--reload` lahko samodejno ponovno zažene strežnik po spremembi kode, kar olajša razvoj.

## Korak 4: Testiranje API-ja

Uporabite API dokumentacijo ali orodja, kot je curl, za testiranje vašega API-ja. Na primer, uporabite curl za pošiljanje POST zahteve:

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

Morali bi prejeti JSON odgovor, ki vsebuje generirano besedilo.

Korak 5: Produkcijska uvedba

Uvedite aplikacijo FastAPI v produkcijsko okolje, na primer:

• Docker: Uporabite Docker za kontejnerizacijo vaše aplikacije, kar olajša uvedbo in upravljanje.
• Platforma v oblaku: Uvedite na platformo v oblaku, kot so AWS, Google Cloud Platform ali Azure. Azure Cosmos DB in Azure Functions, omenjeni v besedilu, se lahko uporabljajo za izgradnjo serverless API-jev. Modal se lahko uporablja tudi za uvedbo samodejno razširljivih aplikacij FastAPI.
• Strežnik: Uvedite na svoj strežnik.

Najboljše prakse

• Uporabite spremenljivke okolja za shranjevanje občutljivih informacij: Ne kodirajte občutljivih informacij, kot so API ključi, v kodo, temveč uporabite spremenljivke okolja.
• Dodajte beleženje: Uporabite modul za beleženje za beleženje stanja delovanja API-ja, kar olajša odpravljanje napak in spremljanje.
• Dodajte obravnavo napak: Uporabite bloke try...except za obravnavo morebitnih izjem in vrnite ustrezne informacije o napaki.
• Omejevanje hitrosti: Uporabite omejevalnik hitrosti, da preprečite zlorabo API-ja. FastAPI ima na voljo nekaj že pripravljenih knjižnic za omejevanje hitrosti.
• Predpomnjenje: Za ponavljajoče se zahteve lahko uporabite predpomnjenje za izboljšanje zmogljivosti.
• Spremljanje: Uporabite orodja za spremljanje za spremljanje zmogljivosti in razpoložljivosti API-ja.

Napredni triki

• Asinhrona obdelava: Za dolgotrajno LLM sklepanje uporabite ključne besede async in await za asinhrono obdelavo, da se izognete blokiranju glavne niti.
• Pretočni odziv: Uporaba pretočnega odziva (StreamingResponse) lahko sproti vrne generirano besedilo, kar izboljša uporabniško izkušnjo.
• Večnitnost/večprocesnost: Za CPU intenzivno LLM sklepanje lahko uporabite večnitnost ali večprocesnost za izboljšanje zmogljivosti.
• GPU pospeševanje: Če vaš LLM model podpira GPU pospeševanje, lahko uporabite CUDA ali druge knjižnice za GPU pospeševanje za izboljšanje hitrosti sklepanja.

ZaključekFastAPI je zmogljivo orodje za izgradnjo visoko zmogljivih, za produkcijo pripravljenih LLM API-jev. S pomočjo tega vodnika lahko hitro postavite LLM API in ga razširite ter optimizirate glede na vaše potrebe. Ne pozabite, da sta stalno učenje in praksa ključna za to, da postanete odličen razvijalec LLM aplikacij. Hornbeam, omenjen v članku, je tudi ASGI strežnik, vreden pozornosti, ki naj bi bil hitrejši in stabilnejši od Gunicorn in se lahko uporablja za uvajanje FastAPI aplikacij.