Construint una API LLM d'alt rendiment i preparada per a la producció amb FastAPI: Guia pas a pas

FastAPI, com a marc web de Python modern i d'alt rendiment, és molt popular per la seva facilitat d'ús, velocitat i documentació d'API generada automàticament. En particular, FastAPI demostra fortes avantatges en la construcció d'API de backend per a aplicacions LLM (Large Language Model). Aquest article us ensenyarà pas a pas com construir una API LLM preparada per a la producció amb FastAPI i explorar algunes de les millors pràctiques.

Per què triar FastAPI?

FastAPI ofereix els següents avantatges clau en la construcció d'API d'aplicacions LLM:

• Alt rendiment: Basat en ASGI, FastAPI pot gestionar sol·licituds d'alta concurrència, que és crucial per a aplicacions LLM que requereixen una resposta ràpida.
• Suport asíncron: FastAPI té suport integrat per a les paraules clau async i await, que poden gestionar convenientment operacions asíncrones, com ara la invocació de la inferència LLM, evitant el bloqueig del fil principal.
• Documentació automàtica de l'API: FastAPI utilitza OpenAPI i JSON Schema per generar automàticament documentació d'API interactiva (Swagger UI), cosa que facilita als desenvolupadors provar i utilitzar la vostra API.
• Validació de dades: FastAPI utilitza Pydantic per a la validació de dades, assegurant la correcció dels paràmetres de la sol·licitud i reduint els errors.
• Injecció de dependències: El sistema d'injecció de dependències de FastAPI pot gestionar i compartir convenientment recursos, com ara models LLM.
• Comunitat activa: FastAPI té una comunitat gran i activa, que pot obtenir recursos i suport abundants.

Preparació

1. Instal·leu Python: Assegureu-vos que teniu instal·lat Python 3.7 o posterior.

2. Instal·leu FastAPI i Uvicorn: Utilitzeu pip per instal·lar FastAPI i Uvicorn (servidor ASGI):

   pip install fastapi uvicorn
   

3. Trieu el model LLM: Trieu el model LLM que voleu utilitzar. Pot ser un model d'OpenAI o un model de codi obert, com TinyLlama. Si trieu OpenAI, heu d'obtenir una clau d'API d'OpenAI. Si trieu TinyLlama, heu de descarregar el fitxer del model.

Pas 1: Creeu una aplicació FastAPI

Creeu un fitxer anomenat main.py i afegiu el codi següent:

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

Aquest codi defineix una aplicació FastAPI i defineix dos models Pydantic: InputText per rebre text d'entrada i OutputText per retornar el text generat.

Pas 2: Afegiu la lògica d'inferència LLM

Afegiu la lògica d'inferència corresponent segons el model LLM que trieu. Aquí prenem com a exemple l'ús de l'API d'OpenAI:

import openai
import os

# Obteniu la clau d'API d'OpenAI
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Es recomana utilitzar variables d'entorn
```@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", # Selecciona el 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))

Aquest codi defineix una ruta /generate que rep un objecte InputText com a entrada, crida l'API d'OpenAI per generar text i retorna el text generat com a objecte OutputText. Tingues en compte que has de substituir text-davinci-003 pel model adequat que hagis seleccionat.

Si utilitzes un model local com TinyLlama, has d'instal·lar la biblioteca corresponent, per exemple transformers, i carregar el model a la memòria. A continuació, es mostra un exemple de codi:

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

Pas 3: Executa l'aplicació FastAPI

Utilitza Uvicorn per executar l'aplicació FastAPI:

uvicorn main:app --reload
```Això iniciarà un servidor local, i pots accedir a `http://127.0.0.1:8000/docs` al navegador per veure la documentació de l'API generada automàticament. El paràmetre `--reload` pot reiniciar automàticament el servidor després de modificar el codi, cosa que facilita el desenvolupament.

## Pas 4: Provar l'API

Utilitza la documentació de l'API o eines com curl per provar la teva API. Per exemple, utilitza curl per enviar una sol·licitud POST:

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

Hauries de rebre una resposta JSON que contingui el text generat.

Pas 5: Implementació en producció

Implementa l'aplicació FastAPI en un entorn de producció, per exemple:

• Docker: Utilitza Docker per a la containerització de la teva aplicació, facilitant la implementació i la gestió.
• Plataforma al núvol: Implementa a una plataforma al núvol, com ara AWS, Google Cloud Platform o Azure. Azure Cosmos DB i Azure Functions esmentats a l'article es poden utilitzar per construir una API sense servidor (serverless). Modal també es pot utilitzar per implementar aplicacions FastAPI d'escalat automàtic.
• Servidor: Implementa al teu propi servidor.

Bones pràctiques

• Utilitza variables d'entorn per emmagatzemar informació sensible: No codifiquis de manera rígida informació sensible com ara claus d'API al codi, sinó que utilitza variables d'entorn.
• Afegeix registre d'esdeveniments (logging): Utilitza el mòdul de registre d'esdeveniments per registrar l'estat d'execució de l'API, cosa que facilita la depuració i el monitoratge.
• Afegeix la gestió d'errors: Utilitza blocs try...except per gestionar les excepcions que puguin ocórrer i retorna la informació d'error adequada.
• Limitació de velocitat: Utilitza un limitador de velocitat per evitar que l'API es faci servir de manera abusiva. FastAPI té algunes biblioteques de limitació de velocitat disponibles.
• Caché: Per a sol·licituds repetides, pots utilitzar la caché per millorar el rendiment.
• Monitoratge: Utilitza eines de monitoratge per monitorar el rendiment i la disponibilitat de l'API.

Trucs avançats

• Processament asíncron: Per a la inferència LLM que requereix molt de temps, utilitza les paraules clau async i await per al processament asíncron, evitant el bloqueig del fil principal.
• Resposta en flux: Utilitzar una resposta en flux (StreamingResponse) pot retornar el text generat en temps real, millorant l'experiència de l'usuari.
• Multithreading/Multiprocessing: Per a la inferència LLM que requereix molta CPU, pots utilitzar multithreading o multiprocessing per millorar el rendiment.
• Acceleració de GPU: Si el teu model LLM admet l'acceleració de GPU, pots utilitzar CUDA o altres biblioteques d'acceleració de GPU per millorar la velocitat d'inferència.

ConclusióFastAPI és una eina potent per construir API LLM d'alt rendiment i preparades per a la producció. Amb la guia d'aquest article, pots configurar ràpidament una API LLM i ampliar-la i optimitzar-la segons les teves necessitats. Recorda, l'aprenentatge i la pràctica constants són la clau per convertir-se en un excel·lent desenvolupador d'aplicacions LLM. Hornbeam, esmentat a l'article, també és un servidor ASGI que val la pena tenir en compte, que afirma ser més ràpid i estable que Gunicorn, i que es pot utilitzar per desplegar aplicacions FastAPI.