Оптимізація вартості AI-інференсу Cost Optimization

Оптимізація вартості AI-інференсу (Cost Optimization)

Інференс AI-моделей у production може коштувати значно дорожче, ніж передбачалося. Витрати на LLM API, GPU-обчислення або managed inference сервіси зростають нелінійно з масштабом. Системна оптимізація дозволяє зменшити витрати на 40-70% без деградації якості.

Аудит поточних витрат

Перший крок – зрозуміти структуру витрат:

• Який відсоток запитів використовує дорогу модель, хоча завдання вирішуване дешевим?
• Яка є cache hit rate? Чи не кешуються запити, що повторюються?
• Який середній розмір контексту? Чи не передаються зайві токени?
• Яка утилізація GPU під час batch inference?

Стратегії оптимізації

1. Model routing – правильна модель для кожного завдання

class IntelligentModelRouter:
    def route_request(self, request: dict) -> str:
        query = request['query']
        complexity = self.complexity_estimator.estimate(query)

        if complexity < 0.3:
            return "gpt-4o-mini"    # $0.15/1M input tokens
        elif complexity < 0.7:
            return "gpt-4o"         # $5.00/1M input tokens
        else:
            return "gpt-4-turbo"    # $10.00/1M input tokens

    def estimate_complexity(self, query: str) -> float:
        # Эвристики: длина, наличие code, math, multi-step reasoning
        features = [
            len(query.split()) / 200,
            1.0 if any(kw in query for kw in ['calculate', 'code', 'step-by-step']) else 0,
            1.0 if '```' in query else 0,
        ]
        return min(np.mean(features) * 1.5, 1.0)

2. Семантичне кешування

from redis import Redis
import numpy as np

class SemanticCache:
    def __init__(self, similarity_threshold: float = 0.95):
        self.redis = Redis()
        self.threshold = similarity_threshold
        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')

    def get(self, query: str) -> str | None:
        query_emb = self.embedder.encode(query)
        cached_keys = self.redis.keys("cache:*")

        for key in cached_keys:
            cached_data = json.loads(self.redis.get(key))
            cached_emb = np.array(cached_data['embedding'])

            similarity = np.dot(query_emb, cached_emb) / (
                np.linalg.norm(query_emb) * np.linalg.norm(cached_emb)
            )
            if similarity > self.threshold:
                return cached_data['response']
        return None

    def set(self, query: str, response: str, ttl: int = 3600):
        key = f"cache:{hashlib.md5(query.encode()).hexdigest()}"
        self.redis.setex(key, ttl, json.dumps({
            'embedding': self.embedder.encode(query).tolist(),
            'response': response
        }))

3. Prompt compression

# LLMLingua для сжатия длинных контекстов
from llmlingua import PromptCompressor

compressor = PromptCompressor(
    model_name="microsoft/llmlingua-2-bert-base-multilingual-cased-meetingbank",
    use_llmlingua2=True
)

compressed = compressor.compress_prompt(
    context,
    rate=0.5,  # Сжать до 50% токенов
    force_tokens=['\n', '?']  # Не сжимать переносы строк и вопросы
)
# Экономия: 40-60% токенов при <5% деградации качества

4. Квантизація для self-hosted інференсу

# 4-bit квантизация модели через bitsandbytes (GPTQ)
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4"
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-70b-chat-hf",
    quantization_config=quantization_config,
    device_map="auto"
)
# 70B модель в 4-bit: ~35GB VRAM вместо ~140GB в BF16

Очікувана економія

Комбінація model routing + semantic caching дає найбільший ефект без ризику деградації більшості production сценаріїв.