Kutumia FastAPI Kujenga API ya LLM yenye Utendaji wa Juu na Tayari kwa Uzalishaji: Mwongozo wa Hatua kwa Hatua

FastAPI, kama mfumo wa kisasa na wenye utendaji wa juu wa Python Web, ni maarufu sana kwa urahisi wake wa matumizi, kasi, na hati za API zinazozalishwa kiotomatiki. Hasa katika kujenga API za nyuma za LLM (Large Language Model) applications, FastAPI inaonyesha faida kubwa. Makala haya yatakufundisha hatua kwa hatua jinsi ya kutumia FastAPI kujenga API ya LLM iliyo tayari kwa uzalishaji, na kujadili baadhi ya mazoea bora.

Kwa nini uchague FastAPI?

Unapojenga API ya LLM application, FastAPI hutoa faida muhimu zifuatazo:

• Utendaji wa Juu: Ikiwa imejengwa juu ya ASGI, FastAPI inaweza kushughulikia maombi mengi kwa wakati mmoja, ambayo ni muhimu kwa LLM applications zinazohitaji majibu ya haraka.
• Usaidizi wa Asynchronous: FastAPI ina usaidizi wa ndani kwa maneno muhimu async na await, ambayo hurahisisha kushughulikia operesheni za asynchronous, kama vile kupiga simu kwa LLM inference, kuepuka kuzuia thread kuu.
• Hati za API za Kiotomatiki: FastAPI hutumia OpenAPI na JSON Schema kuzalisha kiotomatiki hati za API shirikishi (Swagger UI), ambayo hurahisisha wasanidi programu kujaribu na kutumia API yako.
• Uthibitishaji wa Data: FastAPI hutumia Pydantic kwa uthibitishaji wa data, kuhakikisha usahihi wa vigezo vya ombi na kupunguza makosa.
• Utegemezi wa Sindano: Mfumo wa utegemezi wa sindano wa FastAPI hurahisisha kusimamia na kushiriki rasilimali, kama vile LLM model.
• Jumuiya Inayofanya Kazi: FastAPI ina jumuiya kubwa na inayofanya kazi, ambapo unaweza kupata rasilimali na usaidizi mwingi.

Maandalizi

1. Sakinisha Python: Hakikisha umesakinisha Python 3.7 au toleo jipya zaidi.

2. Sakinisha FastAPI na Uvicorn: Tumia pip kusakinisha FastAPI na Uvicorn (ASGI server):

   pip install fastapi uvicorn
   

3. Chagua LLM Model: Chagua LLM model unayotaka kutumia. Inaweza kuwa model ya OpenAI, au model ya open source, kama vile TinyLlama. Ukichagua OpenAI, unahitaji kupata OpenAI API key. Ukichagua TinyLlama, unahitaji kupakua faili ya model.

Hatua ya 1: Unda FastAPI Application

Unda faili inayoitwa main.py, na uongeze msimbo ufuatao:

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

Msimbo huu unafafanua FastAPI application, na kufafanua Pydantic models mbili: InputText hutumiwa kupokea maandishi ya ingizo, na OutputText hutumiwa kurejesha maandishi yaliyozalishwa.

Hatua ya 2: Ongeza LLM Inference Logic

Kulingana na LLM model uliyochagua, ongeza mantiki inayolingana ya inference. Hapa tunatumia OpenAI API kama mfano:

import openai
import os

# Pata OpenAI API key
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Inashauriwa kutumia variable ya mazingira
```@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Huzalisha maandishi kulingana na maandishi ya ingizo kwa kutumia OpenAI.
    """
    try:
        response = openai.Completion.create(
            engine="text-davinci-003", # Chagua 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))

Msimbo huu unafafanua njia ya /generate, ambayo hupokea kitu cha InputText kama ingizo, huita OpenAI API ili kuzalisha maandishi, na hurudisha maandishi yaliyozalishwa kama kitu cha OutputText. Kumbuka kubadilisha text-davinci-003 na modeli inayofaa uliyochagua.

Ikiwa unatumia modeli za ndani kama vile TinyLlama, unahitaji kusakinisha maktaba zinazohusika, kama vile transformers, na kupakia modeli kwenye kumbukumbu. Mfano wa msimbo ni kama ifuatavyo:

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):
    """
    Huzalisha maandishi kulingana na maandishi ya ingizo kwa kutumia 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))

Hatua ya 3: Endesha Programu ya FastAPI

Tumia Uvicorn kuendesha programu ya FastAPI:

uvicorn main:app --reload
```Hii itazindua seva ya ndani, ambayo unaweza kuitembelea kwenye kivinjari chako kupitia `http://127.0.0.1:8000/docs` ili kuona hati za API zilizozalishwa kiotomatiki.  Parameta ya `--reload` inaweza kuwasha upya seva kiotomatiki baada ya mabadiliko ya msimbo, na kuifanya iwe rahisi kwa uendelezaji.

## Hatua ya 4: Jaribu API

Tumia hati za API au zana kama vile curl kujaribu API yako. Kwa mfano, tumia curl kutuma ombi la 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

Unapaswa kupokea jibu la JSON lililo na maandishi yaliyozalishwa.

Hatua ya 5: Usambazaji wa Uzalishaji

Sambaza programu yako ya FastAPI kwenye mazingira ya uzalishaji, kwa mfano:

• Docker: Tumia Docker kuweka programu yako kwenye kontena, ili kurahisisha usambazaji na usimamizi.
• Jukwaa la Wingu: Sambaza kwenye jukwaa la wingu, kama vile AWS, Google Cloud Platform au Azure. Azure Cosmos DB na Azure Functions zilizotajwa kwenye makala zinaweza kutumika kujenga API isiyo na seva. Modal pia inaweza kutumika kusambaza programu za FastAPI zinazopanuka kiotomatiki.
• Seva: Sambaza kwenye seva yako mwenyewe.

Mbinu Bora

• Tumia vigezo vya mazingira kuhifadhi taarifa nyeti: Usiweke misimbo ya API na taarifa zingine nyeti moja kwa moja kwenye msimbo, badala yake tumia vigezo vya mazingira.
• Ongeza kumbukumbu: Tumia moduli ya kumbukumbu kurekodi hali ya uendeshaji ya API, ili kurahisisha utatuzi na ufuatiliaji.
• Ongeza utunzaji wa makosa: Tumia kizuizi cha try...except kushughulikia hitilafu zinazoweza kutokea, na urudishe taarifa sahihi za makosa.
• Kikomo cha kasi: Tumia kikomo cha kasi kuzuia API isitumike vibaya. FastAPI ina maktaba kadhaa za kikomo cha kasi zinazopatikana.
• Akiba: Kwa maombi yanayorudiwa, unaweza kutumia akiba ili kuboresha utendaji.
• Ufuatiliaji: Tumia zana za ufuatiliaji kufuatilia utendaji na upatikanaji wa API.

Mbinu za Juu

• Uchakataji usiolingana: Kwa uamuzi wa LLM unaotumia muda mwingi, tumia maneno muhimu async na await kwa uchakataji usiolingana, ili kuepuka kuzuia uzi mkuu.
• Majibu ya mtiririko: Kutumia majibu ya mtiririko (StreamingResponse) kunaweza kurudisha maandishi yaliyozalishwa kwa wakati halisi, na kuboresha uzoefu wa mtumiaji.
• Nyuzi nyingi/michakato mingi: Kwa uamuzi wa LLM unaotumia CPU nyingi, unaweza kutumia nyuzi nyingi au michakato mingi ili kuboresha utendaji.
• Uharakishaji wa GPU: Ikiwa modeli yako ya LLM inasaidia uharakishaji wa GPU, unaweza kutumia CUDA au maktaba zingine za uharakishaji wa GPU ili kuboresha kasi ya uamuzi.

HitimishoFastAPI ni zana yenye nguvu ya kujenga API za LLM zenye utendaji wa juu na zilizo tayari kwa uzalishaji. Kupitia mwongozo huu, unaweza kuanzisha haraka API ya LLM, na kuipanua na kuiboresha kulingana na mahitaji yako. Kumbuka, kujifunza na kufanya mazoezi endelevu ni muhimu kuwa msanidi programu bora wa programu za LLM. Hornbeam iliyotajwa katika makala pia ni seva ya ASGI inayostahili kuzingatiwa, ikidai kuwa ya haraka na thabiti zaidi kuliko Gunicorn, na inaweza kutumika kupeleka programu za FastAPI.