Naudojant FastAPI sukurti didelio našumo, gamybai paruoštą LLM API: žingsnis po žingsnio vadovas

FastAPI, kaip modernus, didelio našumo Python Web karkasas, yra populiarus dėl savo paprastumo, greičio ir automatiškai generuojamos API dokumentacijos. Ypač kuriant LLM (Large Language Model) programų backend API, FastAPI demonstruoja didelius privalumus. Šiame straipsnyje žingsnis po žingsnio išmokysime, kaip naudoti FastAPI kuriant gamybai paruoštą LLM API, ir aptarsime keletą geriausių praktikų.

Kodėl verta rinktis FastAPI?

Kuriant LLM programų API, FastAPI siūlo šiuos pagrindinius privalumus:

• Didelis našumas: Pagrįstas ASGI, FastAPI gali apdoroti didelio lygiagretaus užklausų skaičiaus, o tai labai svarbu LLM programoms, kurioms reikia greito atsako.
• Asinchroninis palaikymas: FastAPI turi įdiegtą async ir await raktinių žodžių palaikymą, todėl galima patogiai apdoroti asinchronines operacijas, pvz., LLM išvadų iškvietimą, vengiant blokuoti pagrindinę giją.
• Automatinė API dokumentacija: FastAPI naudoja OpenAPI ir JSON Schema automatiškai generuoti interaktyvią API dokumentaciją (Swagger UI), kad kūrėjams būtų patogu išbandyti ir naudoti jūsų API.
• Duomenų patvirtinimas: FastAPI naudoja Pydantic duomenų patvirtinimui, užtikrinant užklausos parametrų teisingumą ir sumažinant klaidas.
• Priklausomybių įterpimas: FastAPI priklausomybių įterpimo sistema leidžia patogiai valdyti ir dalytis ištekliais, pvz., LLM modeliais.
• Aktyvi bendruomenė: FastAPI turi didelę ir aktyvią bendruomenę, kurioje galima gauti daug išteklių ir palaikymo.

Pasiruošimas

1. Įdiekite Python: Įsitikinkite, kad esate įdiegę Python 3.7 arba naujesnę versiją.

2. Įdiekite FastAPI ir Uvicorn: Naudokite pip, kad įdiegtumėte FastAPI ir Uvicorn (ASGI serverį):

   pip install fastapi uvicorn
   

3. Pasirinkite LLM modelį: Pasirinkite LLM modelį, kurį norite naudoti. Tai gali būti OpenAI modelis arba atvirojo kodo modelis, pvz., TinyLlama. Jei pasirinksite OpenAI, turėsite gauti OpenAI API raktą. Jei pasirinksite TinyLlama, turėsite atsisiųsti modelio failą.

1 žingsnis: Sukurkite FastAPI programą

Sukurkite failą pavadinimu main.py ir pridėkite šį kodą:

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

Šis kodas apibrėžia FastAPI programą ir apibrėžia du Pydantic modelius: InputText naudojamas įvesties tekstui gauti, o OutputText naudojamas generuojamam tekstui grąžinti.

2 žingsnis: Pridėkite LLM išvadų logiką

Priklausomai nuo pasirinkto LLM modelio, pridėkite atitinkamą išvadų logiką. Čia kaip pavyzdį naudojamas OpenAI API:

import openai
import os

# Gaukite OpenAI API raktą
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Rekomenduojama naudoti aplinkos kintamąjį
```@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generuoja tekstą pagal įvesties tekstą naudojant OpenAI.
    """
    try:
        response = openai.Completion.create(
            engine="text-davinci-003", # Pasirinkite 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))

Šis kodas apibrėžia /generate maršrutą, kuris priima InputText objektą kaip įvestį, iškviečia OpenAI API tekstui generuoti ir grąžina sugeneruotą tekstą kaip OutputText objektą. Atkreipkite dėmesį, kad text-davinci-003 reikia pakeisti tinkamu pasirinktu modeliu.

Jei naudojate vietinius modelius, tokius kaip TinyLlama, turite įdiegti atitinkamas bibliotekas, pvz., transformers, ir įkelti modelį į atmintį. Kodo pavyzdys:

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):
    """
    Generuoja tekstą pagal įvesties tekstą naudojant 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 žingsnis: paleiskite FastAPI programą

Paleiskite FastAPI programą naudodami Uvicorn:

uvicorn main:app --reload
```Tai paleis vietinį serverį, kurį galėsite pasiekti naršyklėje adresu `http://127.0.0.1:8000/docs` ir peržiūrėti automatiškai sugeneruotą API dokumentaciją. Parametras `--reload` leidžia automatiškai iš naujo paleisti serverį po kodo pakeitimų, kad būtų lengviau kurti.

## 4 žingsnis: API testavimas

Naudokite API dokumentaciją arba tokius įrankius kaip curl, kad patikrintumėte savo API. Pavyzdžiui, naudokite curl, kad išsiųstumėte POST užklausą:

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

Turėtumėte gauti JSON atsakymą su sugeneruotu tekstu.

5 žingsnis: diegimas gamyboje

Įdiekite FastAPI programą gamybos aplinkoje, pavyzdžiui:

• Docker: Naudokite Docker, kad konteinerizuotumėte savo programą, kad būtų lengviau ją diegti ir valdyti.
• Debesų platforma: Įdiekite debesų platformoje, pvz., AWS, Google Cloud Platform arba Azure. Straipsnyje minimos Azure Cosmos DB ir Azure Functions gali būti naudojamos kuriant serverless API. Modal taip pat gali būti naudojamas automatiškai plečiamoms FastAPI programoms diegti.
• Serveris: Įdiekite savo serveryje.

Geriausios praktikos

• Naudokite aplinkos kintamuosius slaptos informacijos saugojimui: Nekoduokite slaptos informacijos, pvz., API raktų, tiesiogiai kode, o naudokite aplinkos kintamuosius.
• Pridėkite žurnalų įrašymą: Naudokite žurnalų įrašymo modulį, kad įrašytumėte API veikimo būseną, kad būtų lengviau derinti ir stebėti.
• Pridėkite klaidų apdorojimą: Naudokite try...except blokus, kad apdorotumėte galimas išimtis ir grąžintumėte atitinkamą klaidos informaciją.
• Spartos ribojimas: Naudokite spartos ribotuvą, kad apsaugotumėte API nuo piktnaudžiavimo. FastAPI turi keletą paruoštų spartos ribojimo bibliotekų.
• Kaupimas talpykloje: Norėdami padidinti našumą, pakartotinėms užklausoms galite naudoti talpyklą.
• Stebėjimas: Naudokite stebėjimo įrankius, kad stebėtumėte API našumą ir prieinamumą.

Išplėstiniai patarimai

• Asinchroninis apdorojimas: Ilgai trunkantiems LLM išvadoms naudokite raktinius žodžius async ir await, kad atliktumėte asinchroninį apdorojimą ir išvengtumėte pagrindinės gijos blokavimo.
• Srautinis atsakas: Naudodami srauto atsaką (StreamingResponse) galite realiuoju laiku grąžinti sugeneruotą tekstą, kad pagerintumėte vartotojo patirtį.
• Daugiagijis / daugiaprocesis: CPU intensyvioms LLM išvadoms galite naudoti daugiagijį arba daugiaprocesį apdorojimą, kad padidintumėte našumą.
• GPU spartinimas: Jei jūsų LLM modelis palaiko GPU spartinimą, galite naudoti CUDA arba kitas GPU spartinimo bibliotekas, kad padidintumėte išvadų greitį.

IšvadaFastAPI yra galingas įrankis kuriant didelio našumo, gamybai paruoštas LLM API. Vadovaudamiesi šiuo straipsniu, galite greitai sukurti LLM API ir išplėsti bei optimizuoti ją pagal savo poreikius. Atminkite, kad nuolatinis mokymasis ir praktika yra raktas į puikų LLM programų kūrėją. Straipsnyje minimas Hornbeam taip pat yra vertas dėmesio ASGI serveris, kuris, kaip teigiama, yra greitesnis ir stabilesnis už Gunicorn ir gali būti naudojamas FastAPI programoms diegti.