Augstas veiktspējas, ražošanai gatava LLM API izveide ar FastAPI: soli pa solim rokasgrāmata

# Augstas veiktspējas, ražošanai gatava LLM API izveide ar FastAPI: soli pa solim rokasgrāmata

FastAPI, kā moderna, augstas veiktspējas Python Web ietvars, ir populārs tā lietošanas vienkāršības, ātruma un automātiski ģenerētas API dokumentācijas dēļ. Īpaši LLM (Large Language Model) lietojumprogrammu aizmugures API izveidē FastAPI demonstrē spēcīgas priekšrocības. Šis raksts soli pa solim iemācīs, kā izveidot ražošanai gatavu LLM API, izmantojot FastAPI, un izpētīs dažas labākās prakses.

## Kāpēc izvēlēties FastAPI?

Veidojot LLM lietojumprogrammu API, FastAPI piedāvā šādas galvenās priekšrocības:

* **Augsta veiktspēja:** Pamatojoties uz ASGI, FastAPI var apstrādāt vienlaicīgus pieprasījumus, kas ir ļoti svarīgi LLM lietojumprogrammām, kurām nepieciešama ātra atbilde.
* **Asinhronais atbalsts:** FastAPI ir iebūvēts `async` un `await` atslēgvārdu atbalsts, kas atvieglo asinhrono darbību apstrādi, piemēram, LLM secinājumu izsaukšanu, izvairoties no galvenās pavediena bloķēšanas.
* **Automātiska API dokumentācija:** FastAPI izmanto OpenAPI un JSON Schema, lai automātiski ģenerētu interaktīvu API dokumentāciju (Swagger UI), kas atvieglo izstrādātājiem jūsu API testēšanu un lietošanu.
* **Datu validācija:** FastAPI izmanto Pydantic datu validācijai, nodrošinot pieprasījuma parametru pareizību un samazinot kļūdas.
* **Atkarību injekcija:** FastAPI atkarību injekcijas sistēma atvieglo resursu, piemēram, LLM modeļu, pārvaldību un koplietošanu.
* **Aktīva kopiena:** FastAPI ir liela un aktīva kopiena, kas var iegūt bagātīgus resursus un atbalstu.

## Sagatavošanās darbi

1. **Python instalēšana:** Pārliecinieties, vai esat instalējis Python 3.7 vai jaunāku versiju.
2. **FastAPI un Uvicorn instalēšana:** Izmantojiet pip, lai instalētu FastAPI un Uvicorn (ASGI serveri):

   ```bash
   pip install fastapi uvicorn

3. LLM modeļa izvēle: Izvēlieties LLM modeli, kuru vēlaties izmantot. Tas var būt OpenAI modelis vai atvērtā koda modelis, piemēram, TinyLlama. Ja izvēlaties OpenAI, jums jāiegūst OpenAI API atslēga. Ja izvēlaties TinyLlama, jums jālejupielādē modeļa fails.

1. solis: FastAPI lietojumprogrammas izveide

Izveidojiet failu ar nosaukumu main.py un pievienojiet šādu kodu:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title=@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", # Izvēlieties modeli
            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 kods definē /generate maršrutu, kas saņem InputText objektu kā ievadi, izsauc OpenAI API, lai ģenerētu tekstu, un atgriež ģenerēto tekstu kā OutputText objektu. Pievērsiet uzmanību, lai aizstātu text-davinci-003 ar atbilstošu modeli, kuru izvēlaties.

Ja izmantojat vietējos modeļus, piemēram, TinyLlama, jums jāinstalē atbilstošās bibliotēkas, piemēram, transformers, un jāielādē modelis atmiņā. Koda piemērs ir šāds:

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. solis: palaidiet FastAPI lietotni

Izmantojiet Uvicorn, lai palaistu FastAPI lietotni:

uvicorn main:app --reload
```Tas sāks lokālu serveri, kuram varat piekļūt pārlūkprogrammā `http://127.0.0.1:8000/docs`, lai skatītu automātiski ģenerētu API dokumentāciju. `--reload` parametrs var automātiski restartēt serveri pēc koda izmaiņām, atvieglojot izstrādi.

## 4. solis: API testēšana

Izmantojiet API dokumentāciju vai tādus rīkus kā curl, lai testētu savu API. Piemēram, izmantojiet curl, lai nosūtītu POST pieprasījumu:

```bash
curl -X POST -H "Content-Type: application/json" -d '{"text": "Pastāsti man joku par kaķiem."}' http://127.0.0.1:8000/generate

Jums vajadzētu saņemt JSON atbildi, kas satur ģenerēto tekstu.

5. solis: Ražošanas izvietošana

Izvietojiet FastAPI lietotni ražošanas vidē, piemēram:

• Docker: Izmantojiet Docker, lai konteinerizētu savu lietotni, atvieglojot izvietošanu un pārvaldību.
• Mākoņplatforma: Izvietojiet mākoņplatformā, piemēram, AWS, Google Cloud Platform vai Azure. Azure Cosmos DB un Azure Functions, kas minēti tekstā, var izmantot, lai izveidotu serverless API. Modal var izmantot arī, lai izvietotu automātiski paplašināmas FastAPI lietotnes.
• Serveris: Izvietojiet savā serverī.

Labākā prakse

• Izmantojiet vides mainīgos, lai uzglabātu sensitīvu informāciju: Nekodējiet API atslēgas un citu sensitīvu informāciju tieši kodā, bet gan izmantojiet vides mainīgos.
• Pievienojiet žurnālēšanu: Izmantojiet žurnālēšanas moduli, lai reģistrētu API darbības statusu, atvieglojot atkļūdošanu un uzraudzību.
• Pievienojiet kļūdu apstrādi: Izmantojiet try...except blokus, lai apstrādātu iespējamās izņēmuma situācijas un atgrieztu atbilstošu kļūdas informāciju.
• Ātruma ierobežošana: Izmantojiet ātruma ierobežotāju, lai novērstu API ļaunprātīgu izmantošanu. FastAPI ir pieejamas dažas gatavas ātruma ierobežošanas bibliotēkas.
• Kešatmiņa: Atkārtotiem pieprasījumiem varat izmantot kešatmiņu, lai uzlabotu veiktspēju.
• Uzraudzība: Izmantojiet uzraudzības rīkus, lai uzraudzītu API veiktspēju un pieejamību.

Papildu padomi

• Asinhronā apstrāde: Ilgstošai LLM secināšanai izmantojiet async un await atslēgvārdus asinhronai apstrādei, lai izvairītos no galvenās pavediena bloķēšanas.
• Straumes atbilde: Izmantojot straumes atbildi (StreamingResponse), varat reāllaikā atgriezt ģenerēto tekstu, uzlabojot lietotāja pieredzi.
• Vairāku pavedienu/vairāku procesu apstrāde: CPU intensīvai LLM secināšanai varat izmantot vairāku pavedienu vai vairāku procesu apstrādi, lai uzlabotu veiktspēju.
• GPU paātrinājums: Ja jūsu LLM modelis atbalsta GPU paātrinājumu, varat izmantot CUDA vai citas GPU paātrinājuma bibliotēkas, lai palielinātu secināšanas ātrumu.

SecinājumsFastAPI ir spēcīgs rīks augstas veiktspējas, ražošanai gatavu LLM API izveidei. Ar šī raksta palīdzību jūs varat ātri izveidot LLM API un paplašināt un optimizēt to atbilstoši savām vajadzībām. Atcerieties, ka nepārtraukta mācīšanās un prakse ir galvenais, lai kļūtu par izcilu LLM lietojumprogrammu izstrādātāju. Rakstā minētais Hornbeam ir arī ASGI serveris, kam ir vērts pievērst uzmanību, jo tas apgalvo, ka ir ātrāks un stabilāks par Gunicorn, un to var izmantot FastAPI lietojumprogrammu izvietošanai.