Budowanie wysokowydajnego, gotowego do produkcji API LLM przy użyciu FastAPI: przewodnik krok po kroku

FastAPI, jako nowoczesny, wysokowydajny framework Python Web, jest popularny ze względu na łatwość użycia, szybkość i automatycznie generowaną dokumentację API. Szczególnie w budowaniu backendowego API dla aplikacji LLM (Large Language Model), FastAPI wykazuje potężne zalety. Ten artykuł krok po kroku nauczy Cię, jak używać FastAPI do budowania gotowego do produkcji API LLM i omówi niektóre najlepsze praktyki.

Dlaczego warto wybrać FastAPI?

Podczas budowania API dla aplikacji LLM, FastAPI oferuje następujące kluczowe zalety:

• Wysoka wydajność: Oparte na ASGI, FastAPI może obsługiwać żądania o wysokiej współbieżności, co jest kluczowe dla aplikacji LLM wymagających szybkiej odpowiedzi.
• Wsparcie asynchroniczne: FastAPI ma wbudowane wsparcie dla słów kluczowych async i await, co ułatwia obsługę operacji asynchronicznych, takich jak wywoływanie wnioskowania LLM, unikając blokowania głównego wątku.
• Automatyczna dokumentacja API: FastAPI używa OpenAPI i JSON Schema do automatycznego generowania interaktywnej dokumentacji API (Swagger UI), ułatwiając programistom testowanie i używanie Twojego API.
• Walidacja danych: FastAPI używa Pydantic do walidacji danych, zapewniając poprawność parametrów żądania i redukując błędy.
• Wstrzykiwanie zależności: System wstrzykiwania zależności FastAPI ułatwia zarządzanie i współdzielenie zasobów, takich jak modele LLM.
• Aktywna społeczność: FastAPI ma dużą i aktywną społeczność, która zapewnia bogate zasoby i wsparcie.

Przygotowanie

1. Zainstaluj Python: Upewnij się, że masz zainstalowaną wersję Python 3.7 lub nowszą.

2. Zainstaluj FastAPI i Uvicorn: Użyj pip do zainstalowania FastAPI i Uvicorn (serwer ASGI):

   pip install fastapi uvicorn
   

3. Wybierz model LLM: Wybierz model LLM, którego chcesz użyć. Może to być model OpenAI lub model open source, taki jak TinyLlama. Jeśli wybierzesz OpenAI, musisz uzyskać klucz API OpenAI. Jeśli wybierzesz TinyLlama, musisz pobrać plik modelu.

Krok 1: Utwórz aplikację FastAPI

Utwórz plik o nazwie main.py i dodaj następujący kod:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="Proste API do interakcji z LLM.")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

Ten kod definiuje aplikację FastAPI i definiuje dwa modele Pydantic: InputText do odbierania tekstu wejściowego i OutputText do zwracania wygenerowanego tekstu.

Krok 2: Dodaj logikę wnioskowania LLM

W zależności od wybranego modelu LLM, dodaj odpowiednią logikę wnioskowania. Tutaj jako przykład użyjemy API OpenAI:

import openai
import os

# Pobierz klucz API OpenAI
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Zaleca się używanie zmiennej środowiskowej
@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", # Wybierz 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 część kodu definiuje routing /generate, który przyjmuje obiekt InputText jako dane wejściowe, wywołuje OpenAI API w celu wygenerowania tekstu i zwraca wygenerowany tekst jako obiekt OutputText. Zwróć uwagę, aby zamienić text-davinci-003 na odpowiedni, wybrany przez Ciebie model.

Jeśli używasz lokalnych modeli, takich jak TinyLlama, musisz zainstalować odpowiednie biblioteki, np. transformers, i załadować model do pamięci. Poniżej znajduje się przykładowy kod:

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

Krok 3: Uruchomienie aplikacji FastAPI

Uruchom aplikację FastAPI za pomocą Uvicorn:

uvicorn main:app --reload
```To uruchomi lokalny serwer, który możesz odwiedzić w przeglądarce pod adresem `http://127.0.0.1:8000/docs`, aby zobaczyć automatycznie wygenerowaną dokumentację API. Parametr `--reload` umożliwia automatyczne ponowne uruchomienie serwera po zmianie kodu, co ułatwia rozwój.

## Krok 4: Testowanie API

Użyj dokumentacji API lub narzędzi takich jak curl do testowania swojego API. Na przykład, użyj curl, aby wysłać żądanie 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

Powinieneś otrzymać odpowiedź JSON zawierającą wygenerowany tekst.

Krok 5: Wdrożenie produkcyjne

Wdróż aplikację FastAPI do środowiska produkcyjnego, na przykład:

• Docker: Użyj Dockera do konteneryzacji swojej aplikacji, co ułatwia wdrażanie i zarządzanie.
• Platforma chmurowa: Wdróż na platformie chmurowej, takiej jak AWS, Google Cloud Platform lub Azure. Wspomniane w tekście Azure Cosmos DB i Azure Functions mogą być użyte do budowy serverless API. Modal może być również użyty do wdrażania automatycznie skalujących się aplikacji FastAPI.
• Serwer: Wdróż na własnym serwerze.

Najlepsze praktyki

• Używaj zmiennych środowiskowych do przechowywania poufnych informacji: Nie zakodowuj na stałe w kodzie poufnych informacji, takich jak klucze API, ale używaj zmiennych środowiskowych.
• Dodaj rejestrowanie: Użyj modułu rejestrowania do rejestrowania stanu działania API, co ułatwia debugowanie i monitorowanie.
• Dodaj obsługę błędów: Użyj bloków try...except do obsługi potencjalnych wyjątków i zwracania odpowiednich komunikatów o błędach.
• Ograniczanie szybkości: Użyj ogranicznika szybkości, aby zapobiec nadużywaniu API. FastAPI ma kilka gotowych bibliotek do ograniczania szybkości.
• Cache: W przypadku powtarzających się żądań możesz użyć cache, aby poprawić wydajność.
• Monitorowanie: Użyj narzędzi do monitorowania, aby monitorować wydajność i dostępność API.

Zaawansowane techniki

• Przetwarzanie asynchroniczne: W przypadku czasochłonnego wnioskowania LLM, użyj słów kluczowych async i await do przetwarzania asynchronicznego, aby uniknąć blokowania głównego wątku.
• Strumieniowe odpowiedzi: Użycie strumieniowych odpowiedzi (StreamingResponse) pozwala na zwracanie generowanego tekstu w czasie rzeczywistym, co poprawia komfort użytkowania.
• Wielowątkowość/wieloprocesowość: W przypadku intensywnego obliczeniowo wnioskowania LLM, możesz użyć wielowątkowości lub wieloprocesowości, aby poprawić wydajność.
• Akceleracja GPU: Jeśli twój model LLM obsługuje akcelerację GPU, możesz użyć CUDA lub innych bibliotek akceleracji GPU, aby zwiększyć szybkość wnioskowania.

WnioskiFastAPI to potężne narzędzie do budowania wysokowydajnych, gotowych do produkcji API LLM. Dzięki przewodnikowi zawartemu w tym artykule możesz szybko skonfigurować API LLM i rozszerzać je oraz optymalizować zgodnie z Twoimi potrzebami. Pamiętaj, że ciągłe uczenie się i praktyka są kluczem do zostania doskonałym programistą aplikacji LLM. Wspomniany w artykule Hornbeam to również serwer ASGI, na który warto zwrócić uwagę, twierdzący, że jest szybszy i bardziej stabilny niż Gunicorn i może być używany do wdrażania aplikacji FastAPI.