FastAPI-ის გამოყენება მაღალი წარმადობის, წარმოებისთვის მზა LLM API-ის ასაგებად: ნაბიჯ-ნაბიჯ სახელმძღვანელო

FastAPI, როგორც თანამედროვე, მაღალი წარმადობის Python Web ფრეიმვორკი, პოპულარულია მისი გამოყენების სიმარტივის, სიჩქარისა და ავტომატურად გენერირებული API დოკუმენტაციის გამო. განსაკუთრებით LLM (Large Language Model) აპლიკაციების უკანა მხარის API-ების აგებისას, FastAPI აჩვენებს ძლიერ უპირატესობებს. ეს სტატია ნაბიჯ-ნაბიჯ გასწავლით, თუ როგორ გამოიყენოთ FastAPI წარმოებისთვის მზა LLM API-ის ასაგებად და განიხილავს რამდენიმე საუკეთესო პრაქტიკას.

რატომ ავირჩიოთ FastAPI?

LLM აპლიკაციის API-ის აგებისას, FastAPI გთავაზობთ შემდეგ საკვანძო უპირატესობებს:

• მაღალი წარმადობა: ASGI-ზე დაფუძნებული, FastAPI-ს შეუძლია მაღალი პარალელური მოთხოვნების დამუშავება, რაც გადამწყვეტია სწრაფი რეაგირების საჭიროების მქონე LLM აპლიკაციებისთვის.
• ასინქრონული მხარდაჭერა: FastAPI-ს აქვს ჩაშენებული მხარდაჭერა async და await საკვანძო სიტყვებისთვის, რაც აადვილებს ასინქრონული ოპერაციების დამუშავებას, როგორიცაა LLM დასკვნების გამოძახება, ძირითადი თრედის დაბლოკვის თავიდან ასაცილებლად.
• ავტომატური API დოკუმენტაცია: FastAPI იყენებს OpenAPI და JSON Schema-ს ინტერაქტიული API დოკუმენტაციის (Swagger UI) ავტომატურად გენერირებისთვის, რაც აადვილებს დეველოპერებს თქვენი API-ის ტესტირებასა და გამოყენებას.
• მონაცემთა ვალიდაცია: FastAPI იყენებს Pydantic-ს მონაცემთა ვალიდაციისთვის, რაც უზრუნველყოფს მოთხოვნის პარამეტრების სისწორეს და ამცირებს შეცდომებს.
• დამოკიდებულების ინექცია: FastAPI-ის დამოკიდებულების ინექციის სისტემა აადვილებს რესურსების მართვასა და გაზიარებას, როგორიცაა LLM მოდელები.
• აქტიური საზოგადოება: FastAPI-ს ჰყავს დიდი და აქტიური საზოგადოება, სადაც შეგიძლიათ მიიღოთ მდიდარი რესურსები და მხარდაჭერა.

მოსამზადებელი სამუშაოები

1. Python-ის ინსტალაცია: დარწმუნდით, რომ დაინსტალირებული გაქვთ Python 3.7 ან უფრო ახალი ვერსია.

2. FastAPI-ისა და Uvicorn-ის ინსტალაცია: გამოიყენეთ pip FastAPI-ისა და Uvicorn-ის (ASGI სერვერი) დასაინსტალირებლად:

   pip install fastapi uvicorn
   

3. LLM მოდელის არჩევა: აირჩიეთ LLM მოდელი, რომლის გამოყენებაც გსურთ. ეს შეიძლება იყოს OpenAI-ის მოდელი, ან ღია კოდის მოდელი, როგორიცაა TinyLlama. თუ აირჩევთ OpenAI-ს, თქვენ უნდა მიიღოთ OpenAI API გასაღები. თუ აირჩევთ TinyLlama-ს, თქვენ უნდა ჩამოტვირთოთ მოდელის ფაილი.

ნაბიჯი 1: FastAPI აპლიკაციის შექმნა

შექმენით ფაილი სახელად main.py და დაამატეთ შემდეგი კოდი:

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

ეს კოდი განსაზღვრავს FastAPI აპლიკაციას და განსაზღვრავს ორ Pydantic მოდელს: InputText გამოიყენება შეყვანის ტექსტის მისაღებად, OutputText გამოიყენება გენერირებული ტექსტის დასაბრუნებლად.

ნაბიჯი 2: LLM დასკვნის ლოგიკის დამატება

თქვენ მიერ არჩეული LLM მოდელის მიხედვით, დაამატეთ შესაბამისი დასკვნის ლოგიკა. აქ მოცემულია OpenAI API-ის გამოყენების მაგალითი:

import openai
import os

# OpenAI API გასაღების მიღება
openai.api_key = os.environ.get("OPENAI_API_KEY")  # რეკომენდებულია გარემოს ცვლადის გამოყენება
```@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", # აირჩიეთ მოდელი
            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))

ეს კოდი განსაზღვრავს /generate მარშრუტს, რომელიც იღებს InputText ობიექტს შეყვანად, იძახებს OpenAI API-ს ტექსტის გენერირებისთვის და აბრუნებს გენერირებულ ტექსტს როგორც OutputText ობიექტს. გაითვალისწინეთ, რომ text-davinci-003 უნდა ჩაანაცვლოთ თქვენთვის სასურველი მოდელით.

თუ იყენებთ ლოკალურ მოდელებს, როგორიცაა TinyLlama, თქვენ უნდა დააინსტალიროთ შესაბამისი ბიბლიოთეკები, როგორიცაა transformers, და ჩატვირთოთ მოდელი მეხსიერებაში. კოდის მაგალითი მოცემულია ქვემოთ:

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: FastAPI აპლიკაციის გაშვება

გაუშვით FastAPI აპლიკაცია Uvicorn-ის გამოყენებით:

uvicorn main:app --reload
```ეს გაუშვებს ლოკალურ სერვერს, რომელზეც შეგიძლიათ ბრაუზერში წვდომა `http://127.0.0.1:8000/docs`-ზე, რათა ნახოთ ავტომატურად გენერირებული API დოკუმენტაცია. `--reload` პარამეტრი საშუალებას გაძლევთ ავტომატურად გადატვირთოთ სერვერი კოდის შეცვლის შემდეგ, რაც აადვილებს განვითარებას.

## ნაბიჯი 4: API-ის ტესტირება

გამოიყენეთ API დოკუმენტაცია ან curl-ის მსგავსი ხელსაწყოები თქვენი API-ის შესამოწმებლად. მაგალითად, გამოიყენეთ curl 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

თქვენ უნდა მიიღოთ JSON პასუხი, რომელიც შეიცავს გენერირებულ ტექსტს.

ნაბიჯი 5: წარმოებაში განთავსება

განათავსეთ FastAPI აპლიკაცია წარმოების გარემოში, მაგალითად:

• Docker: გამოიყენეთ Docker თქვენი აპლიკაციის კონტეინერიზაციისთვის, რაც აადვილებს განთავსებას და მართვას.
• ღრუბლოვანი პლატფორმა: განათავსეთ ღრუბლოვან პლატფორმაზე, როგორიცაა AWS, Google Cloud Platform ან Azure. ტექსტში ნახსენები Azure Cosmos DB და Azure Functions შეიძლება გამოყენებულ იქნას serverless API-ის ასაგებად. Modal ასევე შეიძლება გამოყენებულ იქნას ავტომატურად გაფართოებადი FastAPI აპლიკაციების განსათავსებლად.
• სერვერი: განათავსეთ თქვენს საკუთარ სერვერზე.

საუკეთესო პრაქტიკა

• გამოიყენეთ გარემოს ცვლადები სენსიტიური ინფორმაციის შესანახად: არ ჩაწეროთ API გასაღებები და სხვა სენსიტიური ინფორმაცია კოდში, არამედ გამოიყენეთ გარემოს ცვლადები.
• დაამატეთ ჟურნალების ჩაწერა: გამოიყენეთ ჟურნალების ჩაწერის მოდული API-ის მუშაობის სტატუსის ჩასაწერად, რაც აადვილებს გამართვასა და მონიტორინგს.
• დაამატეთ შეცდომების დამუშავება: გამოიყენეთ try...except ბლოკები შესაძლო გამონაკლისების დასამუშავებლად და შესაბამისი შეცდომის შეტყობინებების დასაბრუნებლად.
• სიჩქარის შეზღუდვა: გამოიყენეთ სიჩქარის შემზღუდველი API-ის ბოროტად გამოყენების თავიდან ასაცილებლად. FastAPI-ს აქვს რამდენიმე მზა სიჩქარის შეზღუდვის ბიბლიოთეკა.
• ქეშირება: განმეორებადი მოთხოვნებისთვის შეგიძლიათ გამოიყენოთ ქეშირება მუშაობის გასაუმჯობესებლად.
• მონიტორინგი: გამოიყენეთ მონიტორინგის ხელსაწყოები API-ის მუშაობისა და ხელმისაწვდომობის მონიტორინგისთვის.

მოწინავე ხრიკები

• ასინქრონული დამუშავება: დროში ხანგრძლივი LLM დასკვნისთვის გამოიყენეთ async და await საკვანძო სიტყვები ასინქრონული დამუშავებისთვის, რათა თავიდან აიცილოთ ძირითადი თემის დაბლოკვა.
• ნაკადური პასუხი: ნაკადური პასუხის (StreamingResponse) გამოყენებით შეგიძლიათ რეალურ დროში დააბრუნოთ გენერირებული ტექსტი, რაც აუმჯობესებს მომხმარებლის გამოცდილებას.
• მრავალთემა/მრავალპროცესი: CPU ინტენსიური LLM დასკვნისთვის შეგიძლიათ გამოიყენოთ მრავალთემა ან მრავალპროცესი მუშაობის გასაუმჯობესებლად.
• GPU აჩქარება: თუ თქვენი LLM მოდელი მხარს უჭერს GPU აჩქარებას, შეგიძლიათ გამოიყენოთ CUDA ან სხვა GPU აჩქარების ბიბლიოთეკა დასკვნის სიჩქარის გასაუმჯობესებლად.

დასკვნაFastAPI არის მძლავრი ინსტრუმენტი მაღალი წარმადობის, წარმოებისთვის მზა LLM API-ების ასაწყობად. ამ სტატიის სახელმძღვანელოს საშუალებით, თქვენ შეგიძლიათ სწრაფად ააწყოთ LLM API და გააფართოვოთ და ოპტიმიზაცია გაუკეთოთ ის თქვენი საჭიროებების შესაბამისად. დაიმახსოვრეთ, მუდმივი სწავლა და პრაქტიკა არის LLM აპლიკაციების შესანიშნავი დეველოპერი გახდომის გასაღები. სტატიაში ნახსენები Hornbeam ასევე არის ASGI სერვერი, რომელსაც ყურადღება უნდა მიექცეს, რომელიც აცხადებს, რომ უფრო სწრაფი და სტაბილურია ვიდრე Gunicorn და შეიძლება გამოყენებულ იქნას FastAPI აპლიკაციების განსათავსებლად.