FastAPI abil suure jõudlusega ja tootmiseks valmis LLM API loomine: samm-sammult juhend

# FastAPI abil suure jõudlusega ja tootmiseks valmis LLM API loomine: samm-sammult juhend

FastAPI, kui kaasaegne ja suure jõudlusega Pythoni veebiraamistik, on populaarne oma kasutusmugavuse, kiiruse ja automaatselt genereeritud API dokumentatsiooni tõttu. Eriti LLM (Large Language Model) rakenduste taustarakenduse API-de loomisel näitab FastAPI suurt eelist. See artikkel õpetab teile samm-sammult, kuidas kasutada FastAPI-d tootmiseks valmis LLM API loomiseks, ja uurib mõningaid parimaid praktikaid.

## Miks valida FastAPI?

LLM-i rakenduste API-de loomisel pakub FastAPI järgmisi peamisi eeliseid:

* **Suur jõudlus:** ASGI-l põhinev FastAPI suudab käsitleda suure koormusega samaaegseid päringuid, mis on kiire reageerimise vajaduse korral LLM-i rakenduste jaoks ülioluline.
* **Asünkroonne tugi:** FastAPI-l on sisseehitatud tugi märksõnadele `async` ja `await`, mis võimaldab mugavalt käsitleda asünkroonseid toiminguid, näiteks LLM-i järelduste kutsumist, vältides peamise lõime blokeerimist.
* **Automaatne API dokumentatsioon:** FastAPI genereerib OpenAPI ja JSON Schema abil automaatselt interaktiivse API dokumentatsiooni (Swagger UI), mis võimaldab arendajatel teie API-t mugavalt testida ja kasutada.
* **Andmete valideerimine:** FastAPI kasutab Pydanticut andmete valideerimiseks, tagades päringuparameetrite õigsuse ja vähendades vigu.
* **Sõltuvuse süstimine:** FastAPI sõltuvuse süstimise süsteem võimaldab mugavalt hallata ja jagada ressursse, näiteks LLM-i mudeleid.
* **Aktiivne kogukond:** FastAPI-l on suur ja aktiivne kogukond, kust saab rikkalikult ressursse ja tuge.

## Ettevalmistused

1. **Installige Python:** Veenduge, et teil on installitud Python 3.7 või uuem versioon.
2. **Installige FastAPI ja Uvicorn:** Installige FastAPI ja Uvicorn (ASGI server) pip abil:

   ```bash
   pip install fastapi uvicorn

3. Valige LLM mudel: Valige LLM mudel, mida soovite kasutada. See võib olla OpenAI mudel või avatud lähtekoodiga mudel, näiteks TinyLlama. Kui valite OpenAI, peate hankima OpenAI API võtme. Kui valite TinyLlama, peate alla laadima mudelifaili.

Samm 1: FastAPI rakenduse loomine

Looge fail nimega main.py ja lisage järgmine kood:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="Lihtne API LLM-idega suhtlemiseks.")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

See kood määratleb FastAPI rakenduse ja määratleb kaks Pydanticu mudelit: InputText sisendteksti vastuvõtmiseks ja OutputText genereeritud teksti tagastamiseks.

Samm 2: LLM-i järeldusloogika lisamine

Lisage vastavalt valitud LLM-i mudelile vastav järeldusloogika. Siin on näide OpenAI API kasutamisest:

import openai
import os

# Hankige OpenAI API võti
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Soovitatav on kasutada keskkonnamuutujaid

@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", # Vali mudel 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))

See kood defineerib `/generate` marsruudi, mis võtab sisendina `InputText` objekti, kutsub OpenAI API teksti genereerimiseks ja tagastab genereeritud teksti `OutputText` objektina. Pange tähele, et `text-davinci-003` tuleb asendada sobiva valitud mudeliga.

**Kui kasutate kohalikke mudeleid, nagu TinyLlama, peate installima vastavad teegid, näiteks `transformers`, ja laadima mudeli mällu. Koodinäide on järgmine:**

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

Samm 3: Käivitage FastAPI rakendus

Käivitage FastAPI rakendus Uvicorniga:

uvicorn main:app --reload
```See käivitab kohaliku serveri, millele pääsete brauseris juurde aadressil `http://127.0.0.1:8000/docs`, et vaadata automaatselt genereeritud API dokumentatsiooni. `--reload` parameeter võimaldab koodi muutmise järel serveri automaatselt taaskäivitada, mis on arendamisel mugav.

## Samm 4: API testimine

Kasutage API dokumentatsiooni või tööriistu nagu curl oma API testimiseks. Näiteks kasutage curli, et saata POST päring:

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

Peaksite saama JSON vastuse, mis sisaldab genereeritud teksti.

Samm 5: Tootmises juurutamine

Juurutage oma FastAPI rakendus tootmiskeskkonda, näiteks:

• Docker: Kasutage Dockerit oma rakenduse konteineriseerimiseks, et seda oleks lihtne juurutada ja hallata.
• Pilveplatvorm: Juurutage pilveplatvormile, näiteks AWS, Google Cloud Platform või Azure. Artiklis mainitud Azure Cosmos DB ja Azure Functions võivad olla kasutatud serverless API ehitamiseks. Modalit saab kasutada ka automaatselt skaleeruva FastAPI rakenduse juurutamiseks.
• Server: Juurutage oma serverisse.

Parimad praktikad

• Kasutage tundliku teabe salvestamiseks keskkonnamuutujaid: Ärge kodeerige API võtmeid ja muud tundlikku teavet otse koodi, vaid kasutage keskkonnamuutujaid.
• Lisage logimine: Kasutage logimismoodulit API tööoleku salvestamiseks, et hõlbustada silumist ja jälgimist.
• Lisage veatöötlus: Kasutage try...except plokke võimalike erandite käsitlemiseks ja sobivate veateadete tagastamiseks.
• Kiiruse piiramine: Kasutage kiiruse piirajat, et vältida API kuritarvitamist. FastAPI jaoks on saadaval mõned valmis kiiruse piiramise teegid.
• Vahemälu: Korduvate päringute korral saate jõudluse parandamiseks kasutada vahemälu.
• Jälgimine: Kasutage jälgimistööriistu API jõudluse ja kättesaadavuse jälgimiseks.

Täpsemad nipid

• Asünkroonne töötlemine: Aeganõudva LLM järelduse jaoks kasutage asünkroonseks töötlemiseks märksõnu async ja await, et vältida põhivoo blokeerimist.
• Voogedastusvastus: Voogedastusvastuse (StreamingResponse) abil saate genereeritud teksti reaalajas tagastada, et parandada kasutajakogemust.
• Mitmelõimelisus/mitmeprotsessilisus: CPU-mahuka LLM järelduse jaoks saate jõudluse parandamiseks kasutada mitmelõimelisust või mitmeprotsessilisust.
• GPU kiirendus: Kui teie LLM mudel toetab GPU kiirendust, saate järelduskiiruse suurendamiseks kasutada CUDA-t või muid GPU kiirendusraamatukogusid.

JäreldusFastAPI on võimas tööriist suure jõudlusega ja tootmisvalmis LLM API-de loomiseks. Selle artikli juhendi abil saate kiiresti luua LLM API ja seda vastavalt oma vajadustele laiendada ja optimeerida. Pidage meeles, et pidev õppimine ja praktika on suurepäraseks LLM-i rakenduste arendajaks saamisel võtmetähtsusega. Artiklis mainitud Hornbeam on samuti tähelepanu vääriv ASGI server, mis väidetavalt on Gunicornist kiirem ja stabiilsem ning mida saab kasutada FastAPI rakenduste juurutamiseks.