Membina API LLM Berprestasi Tinggi dan Sedia Pengeluaran dengan FastAPI: Panduan Langkah demi Langkah
Membina API LLM Berprestasi Tinggi dan Sedia Pengeluaran dengan FastAPI: Panduan Langkah demi Langkah
FastAPI, sebagai rangka kerja Web Python moden dan berprestasi tinggi, popular kerana kemudahan penggunaan, kelajuan dan dokumentasi API yang dijana secara automatik. Terutamanya dalam membina API bahagian belakang untuk aplikasi LLM (Large Language Model), FastAPI menunjukkan kelebihan yang kuat. Artikel ini akan mengajar anda langkah demi langkah cara membina API LLM sedia pengeluaran menggunakan FastAPI, dan meneroka beberapa amalan terbaik.
Mengapa Memilih FastAPI?
Apabila membina API untuk aplikasi LLM, FastAPI menawarkan kelebihan utama berikut:
- Prestasi Tinggi: Berdasarkan ASGI, FastAPI boleh mengendalikan permintaan konkurensi tinggi, yang penting untuk aplikasi LLM yang memerlukan respons pantas.
- Sokongan Asinkronus: FastAPI mempunyai sokongan terbina dalam untuk kata kunci
asyncdanawait, yang memudahkan pengendalian operasi asinkronus, seperti memanggil inferens LLM, mengelakkan penyekatan thread utama. - Dokumentasi API Automatik: FastAPI menggunakan OpenAPI dan JSON Schema untuk menjana dokumentasi API interaktif secara automatik (Swagger UI), memudahkan pembangun untuk menguji dan menggunakan API anda.
- Pengesahan Data: FastAPI menggunakan Pydantic untuk pengesahan data, memastikan ketepatan parameter permintaan dan mengurangkan ralat.
- Suntikan Kebergantungan: Sistem suntikan kebergantungan FastAPI memudahkan untuk mengurus dan berkongsi sumber, seperti model LLM.
- Komuniti Aktif: FastAPI mempunyai komuniti yang besar dan aktif, dan anda boleh mendapatkan sumber dan sokongan yang kaya.
Persediaan
-
Pasang Python: Pastikan anda telah memasang Python 3.7 atau versi yang lebih tinggi.
-
Pasang FastAPI dan Uvicorn: Gunakan pip untuk memasang FastAPI dan Uvicorn (pelayan ASGI):
pip install fastapi uvicorn -
Pilih Model LLM: Pilih model LLM yang ingin anda gunakan. Ia boleh menjadi model OpenAI, atau model sumber terbuka, seperti TinyLlama. Jika anda memilih OpenAI, anda perlu mendapatkan kunci API OpenAI. Jika anda memilih TinyLlama, anda perlu memuat turun fail model.
Langkah 1: Cipta Aplikasi FastAPI
Cipta fail bernama main.py, dan tambahkan kod berikut:
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI(title="LLM API", description="API mudah untuk berinteraksi dengan LLM.")
class InputText(BaseModel):
text: str
class OutputText(BaseModel):
generated_text: str
Kod ini mentakrifkan aplikasi FastAPI, dan mentakrifkan dua model Pydantic: InputText digunakan untuk menerima teks input, OutputText digunakan untuk mengembalikan teks yang dijana.
Langkah 2: Tambah Logik Inferens LLM
Bergantung pada model LLM yang anda pilih, tambahkan logik inferens yang sepadan. Di sini, contohnya menggunakan API OpenAI:
import openai
import os
# Dapatkan kunci API OpenAI
openai.api_key = os.environ.get("OPENAI_API_KEY") # Dicadangkan untuk menggunakan pembolehubah persekitaran
```@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
"""
Menjana teks berdasarkan teks input menggunakan OpenAI.
"""
try:
response = openai.Completion.create(
engine="text-davinci-003", # Pilih 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))
Kod ini mentakrifkan laluan /generate, yang menerima objek InputText sebagai input, memanggil OpenAI API untuk menjana teks, dan mengembalikan teks yang dijana sebagai objek OutputText. Sila ambil perhatian untuk menggantikan text-davinci-003 dengan model yang sesuai yang anda pilih.
Jika menggunakan model tempatan seperti TinyLlama, anda perlu memasang pustaka yang berkaitan, contohnya transformers, dan memuatkan model ke dalam memori. Contoh kod adalah seperti berikut:
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):
"""
Menjana teks berdasarkan teks input menggunakan 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))
Langkah 3: Jalankan Aplikasi FastAPI
Jalankan aplikasi FastAPI menggunakan Uvicorn:
uvicorn main:app --reload
```Ini akan memulakan pelayan tempatan, dan anda boleh melawati `http://127.0.0.1:8000/docs` dalam pelayar untuk melihat dokumentasi API yang dijana secara automatik. Parameter `--reload` boleh memulakan semula pelayan secara automatik selepas kod diubah suai, yang memudahkan pembangunan.
## Langkah 4: Uji API
Gunakan dokumentasi API atau alat seperti curl untuk menguji API anda. Contohnya, gunakan curl untuk menghantar permintaan 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
Anda sepatutnya menerima respons JSON yang mengandungi teks yang dijana.
Langkah 5: Pelaksanaan Pengeluaran
Laksanakan aplikasi FastAPI anda ke persekitaran pengeluaran, contohnya:
- Docker: Gunakan Docker untuk mengkontainerkan aplikasi anda, memudahkan pelaksanaan dan pengurusan.
- Platform Awan: Laksanakan ke platform awan, seperti AWS, Google Cloud Platform atau Azure. Azure Cosmos DB dan Azure Functions yang disebut dalam artikel boleh digunakan untuk membina API tanpa pelayan (serverless API). Modal juga boleh digunakan untuk melaksanakan aplikasi FastAPI yang berkembang secara automatik.
- Pelayan: Laksanakan ke pelayan anda sendiri.
Amalan Terbaik
- Gunakan pemboleh ubah persekitaran untuk menyimpan maklumat sensitif: Jangan kodkan kunci API dan maklumat sensitif lain secara tegar dalam kod, tetapi gunakan pemboleh ubah persekitaran.
- Tambahkan pengelogan: Gunakan modul pengelogan untuk merekodkan status operasi API, memudahkan penyahpepijatan dan pemantauan.
- Tambahkan pengendalian ralat: Gunakan blok
try...exceptuntuk mengendalikan pengecualian yang mungkin berlaku dan mengembalikan maklumat ralat yang sesuai. - Had kadar: Gunakan pengehad kadar untuk mengelakkan API daripada disalahgunakan. FastAPI mempunyai beberapa pustaka pengehad kadar yang sedia ada.
- Cache: Untuk permintaan berulang, anda boleh menggunakan cache untuk meningkatkan prestasi.
- Pemantauan: Gunakan alat pemantauan untuk memantau prestasi dan ketersediaan API.
Teknik Lanjutan
- Pemprosesan tak segerak: Untuk inferens LLM yang memakan masa, gunakan kata kunci
asyncdanawaituntuk pemprosesan tak segerak, elakkan menyekat thread utama. - Respons penstriman: Menggunakan respons penstriman (StreamingResponse) boleh mengembalikan teks yang dijana dalam masa nyata, meningkatkan pengalaman pengguna.
- Berbilang thread/berbilang proses: Untuk inferens LLM yang intensif CPU, anda boleh menggunakan berbilang thread atau berbilang proses untuk meningkatkan prestasi.
- Pecutan GPU: Jika model LLM anda menyokong pecutan GPU, anda boleh menggunakan CUDA atau pustaka pecutan GPU lain untuk meningkatkan kelajuan inferens.
