Цена и бавност: бюджет, кеш, по-малък модел в Python

Проблем

Сметката в края на месеца

Асистентът на поддръжката работи от месец. Отговаря вярно, а наборът от урока за оценяването минава. После идват две оплаквания: сметката за модела е по-висока от очакваното, а клиентите чакат за отговор около секунда.

Ето едно извикване, както го прави асистентът. Цените на токените са примерни, в евро за милион токена:

question = "Колко струва доставката?"
r = CLIENT.create(model=LARGE, max_tokens=1024, system=PROMPT + " " + ALL_DOCS, messages=[{"role": "user", "content": question}])
m = MODELS[LARGE]
euro = cost(m, r.usage)
input_euro = r.usage.input_tokens * m.in_price / 1_000_000
print(f"вход: {r.usage.input_tokens} токена, изход: {r.usage.output_tokens} токена")
print(f"цена: {euro:.5f} € (входът е {100 * input_euro / euro:.0f}%)")
print(f"примерно време: {latency(m, r.usage)} ms")

вход: 314 токена, изход: 32 токена
цена: 0.00177 € (входът е 71%)
примерно време: 1071 ms

Въпросът „Колко струва доставката?“ е 6 токена, а входът е 314. Част от сметката е отговорът, а по-голямата част е входът: системният промпт и всички документи на магазина пътуват с всеки въпрос. А в дневника половината въпроси са едни и същи: колко струва доставката, кога работи поддръжката.

Идеята

Откъде идват парите и времето

Моделът се плаща на токени (урокът за токените), отделно за входа и за изхода:

входът е всичко, което пращаш: системният промпт, документите, историята на разговора, въпросът. API-то няма памет, затова това се праща всеки път (урокът за контекста);
изходът е отговорът. Токен изход обикновено струва няколко пъти повече от токен вход, тук 4 пъти.

Времето е подобно, но с друг баланс. Моделът чете входа бързо, а отговора го пише токен по токен. Затова дългият отговор е бавен, а дългият вход е най-вече скъп.

Оттук и трите поправки, които урокът мери с програма:

бюджет на токени: по-малко вход (само нужното) и таван за изхода;
кеш: еднаквият въпрос не стига до модела;
по-малък модел за лесните въпроси: по-евтин и по-бърз токен.

Бюджетът на токени е горна граница на токените на едно извикване, планирана предварително, както планираш паметта или времето за отговор на една заявка.

Виж го

Асистентът в код

Фалшивият клиент е същият като в урока за оценяването: формата на истинското API, записани отговори и груби токени (всяка дума е 2 токена). Отговорите са записани по дума във въпроса:

# фалшив клиент: формата на истинското API, отговорите са записани
@dataclass(frozen=True)
class Usage:
    input_tokens: int
    output_tokens: int


@dataclass(frozen=True)
class Response:
    text: str
    stop_reason: str
    usage: Usage


# записан отговор: модел ("" = всеки), дума във въпроса, нужен текст в промпта
@dataclass(frozen=True)
class Recorded:
    model: str
    keyword: str
    needs: str
    text: str


# грубо: всяка дума е 2 токена
def tokens(text):
    return 2 * len(text.split())


# max_tokens реже отговора
def reply(text, max_tokens, input_tokens):
    words = text.split(" ")
    if 2 * len(words) <= max_tokens:
        return Response(text, "end_turn", Usage(input_tokens, 2 * len(words)))
    kept = max_tokens // 2
    return Response(" ".join(words[:kept]), "max_tokens", Usage(input_tokens, 2 * kept))


class FakeLlm:
    def __init__(self, recorded):
        self.recorded = recorded

    def create(self, model, max_tokens, system, messages):
        question = messages[-1]["content"]
        input_tokens = tokens(system) + sum(tokens(m["content"]) for m in messages)
        for r in self.recorded:
            if r.model in ("", model) and r.keyword in question and r.needs in system:
                return reply(r.text, max_tokens, input_tokens)
        return reply("(няма записан отговор)", max_tokens, input_tokens)

RECORDED = [
    Recorded("", "струва", "", "Доставката до адрес е 4,90 €, до офис 3,50 €, а над 50 € е безплатна."),
    Recorded("", "наложен", "", "Да, може с наложен платеж. Таксата е 1,50 €."),
    Recorded("", "върна", "", "Можеш да върнеш стоката до 14 дни след доставката, ако е запазена и с етикета."),
    Recorded("", "работи", "", "Поддръжката работи от понеделник до петък, от 9 до 18 ч."),
    Recorded("", "1042", "", "Поръчка 1042 е изпратена и пристига в четвъртък."),
    Recorded("", "1077", "", "Поръчка 1077 се приготвя и тръгва утре."),
    Recorded("", "повредена", "", "Съжалявам! Снимай пратката и етикета и ни пиши с номера на поръчката. Ще ти изпратим нова или ще върнем парите до 5 работни дни."),
    Recorded("", "дни", "", "Пратките пристигат за 2 до 4 работни дни."),
    Recorded("", "едро", "", "Не знам, ще те свържа с колега."),
    Recorded("", "Mastercard", "", "Да, приемаме Visa и Mastercard."),
]

Документите на магазина са пет раздела. Всеки има думи, по които се познава:

# раздел от документите и думите, по които се познава
@dataclass(frozen=True)
class Doc:
    triggers: list
    text: str


PROMPT = "Ти си асистентът на поддръжката на онлайн магазин. Отговаряй кратко и само от документите. Ако отговорът го няма, кажи: „Не знам, ще те свържа с колега.“"
DOCS = [
    Doc(["доставка", "пратка"], "Доставка: пратките пристигат за 2 до 4 работни дни. До адрес доставката струва 4,90 €, до офис на куриер 3,50 €, а над 50 € е безплатна. Пратката се следи по номера ѝ."),
    Doc(["върна", "повредена"], "Връщане: стоката се връща до 14 дни след доставката, ако е запазена и с етикета. Повредена пратка се снима и се пише на поддръжката. Парите се връщат по картата до 5 работни дни."),
    Doc(["плат", "карт", "mastercard"], "Плащане: приемаме Visa и Mastercard. Наложеният платеж е с такса 1,50 €. Плащането с карта е защитено, а сумата се тегли при потвърждаване на поръчката."),
    Doc(["поръчка"], "Поръчки: статусът на поръчката се вижда в профила. Поддръжката проверява поръчка само по номера ѝ и никога не иска данните на картата."),
    Doc(["работи", "работно"], "Поддръжка: работим от понеделник до петък, от 9 до 18 ч. Пиши ни на help@shop.example."),
]
ALL_DOCS = " ".join(doc.text for doc in DOCS)

Моделите, цените и времената. Всички числа тук са примерни, а времето е по формула, не е мерено:

# примерни цени в € за 1 000 000 токена и примерно време (не са мерени)
@dataclass(frozen=True)
class ModelInfo:
    in_price: float
    out_price: float
    base_ms: int
    input_per_ms: int
    ms_per_token: int


LARGE, SMALL = "model-large", "model-small"
MODELS = {
    LARGE: ModelInfo(4.00, 16.00, 400, 10, 20),
    SMALL: ModelInfo(0.40, 1.60, 150, 40, 5),
}
CACHE_MS = 5

# цената на едно извикване в €
def cost(m, u):
    return (u.input_tokens * m.in_price + u.output_tokens * m.out_price) / 1_000_000


# примерно време в ms: начало + прочитане на входа + генериране
def latency(m, u):
    return m.base_ms + u.input_tokens // m.input_per_ms + u.output_tokens * m.ms_per_token

Отговорът за поръчка 1042 е записан. В истинския асистент статусът идва от инструмент (урокът за инструментите).

1_000_000 е същото като 1000000. // е целочислено деление, както / между цели числа в Java и C#.

Пробвай

Попълни

Цената е токените вход по цената на входа плюс токените изход по…?

return (u.input_tokens * m.in_price + u.output_tokens * ) / 1_000_000

Виж го

Един ден

Ден в поддръжката е мостра от 20 въпроса. Някои се повтарят, понякога с малка буква или с излишен интервал. Три са за конкретна поръчка:

questions = [
    "Колко струва доставката?",
    "Кога работи поддръжката?",
    "Къде е поръчка 1042?",
    "колко струва доставката?",
    "Мога ли да платя с наложен платеж?",
    "До кога мога да върна стоката?",
    "Колко струва доставката?",
    "Пратката ми дойде повредена, какво да правя?",
    "Кога работи поддръжката?",
    "Къде е поръчка 1077?",
    "Приемате ли Mastercard?",
    "Колко струва  доставката? ",
    "За колко дни идва пратка до Бургас?",
    "Мога ли да платя с наложен платеж?",
    "Продавате ли на едро?",
    "До кога мога да върна стоката?",
    "Къде е поръчка 1042?",
    "Кога работи поддръжката?",
    "Колко струва доставката до офис?",
    "Как да върна стоката?",
]

day пуска въпросите и събира цената и времето. Трите флага включват трите поправки, засега са изключени:

def day(questions, budget, cache, route):
    answers = {}
    euro, ms, hits, on_small = 0.0, 0, 0, 0
    for question in questions:
        k = key(question)
        # попадение: без модел
        if cache and k in answers:
            hits += 1
            ms += CACHE_MS
            continue
        model = pick_model(question) if route else LARGE
        docs = relevant(question) if budget else ALL_DOCS
        max_tokens = 200 if budget else 1024
        msg = {"role": "user", "content": question}
        r = CLIENT.create(model=model,
                          max_tokens=max_tokens,
                          system=PROMPT + " " + docs,
                          messages=[msg])
        m = MODELS[model]
        euro += cost(m, r.usage)
        ms += latency(m, r.usage)
        if model == SMALL:
            on_small += 1
        # поръчката е на един клиент: не се кешира
        if cache and "поръчка" not in k:
            answers[k] = r.text
    return Totals(euro, ms, hits, on_small)

def row(name, t, n):
    print(f"{name}: {t.euro / n * 1000:.2f} € за 1000 въпроса, средно {t.ms // n} ms")


def month(t, n):
    print(f"месец при 3000 въпроса на ден: {t.euro / n * 3000 * 30:.2f} €")

all = day(questions, False, False, False)
row("голям модел, всички документи", all, len(questions))
month(all, len(questions))

голям модел, всички документи: 1.66 € за 1000 въпроса, средно 917 ms
месец при 3000 въпроса на ден: 149.08 €

Цената за 1000 въпроса е под 2 €. При 3000 въпроса на ден месецът е около 150 €, а един въпрос чака средно почти секунда.

Идеята

Бюджет на токени

Първата поправка е входът. На въпроса за доставката трябва само разделът за доставката. relevant взима разделите, чиито думи има във въпроса, а ако няма нито един, праща всички (въпросът „на едро“ трябва да види всичко, за да каже „Не знам“):

# бюджет: само разделите, чиито думи има във въпроса
def relevant(question):
    low = question.lower()
    parts = [doc.text for doc in DOCS if any(word in low for word in doc.triggers)]
    return " ".join(parts) if parts else ALL_DOCS

Вторият таван е max_tokens: най-много 200 токена за отговор. Той не прави отговорите по-кратки. Той казва колко най-много може да струва едно извикване.

all = day(questions, False, False, False)
row("голям модел, всички документи", all, len(questions))
budget = day(questions, True, False, False)
row("+ бюджет на токени", budget, len(questions))

голям модел, всички документи: 1.66 € за 1000 въпроса, средно 917 ms
+ бюджет на токени: 0.90 € за 1000 въпроса, средно 898 ms

Цената пада почти наполовина. Времето почти не мърда: входът се чете бързо, а отговорът е същият.

Тук разделите се избират по думи. Как се избират по смисъл, с вектори, е в модула за търсене по смисъл (RAG).

any(word in low for word in doc.triggers) е вярно, ако поне една дума от раздела се съдържа във въпроса.

Пробвай

Предвиди изхода

max_tokens е 10, а въпросът е за повредена пратка. Какво ще отпечата?

r = CLIENT.create(model=LARGE, max_tokens=10, system=PROMPT, messages=[{"role": "user", "content": "Пратката ми дойде повредена, какво да правя?"}])
print(r.text)
print(f"{r.stop_reason}, {r.usage.output_tokens}")

Отговор

Съжалявам! Снимай пратката и етикета и ни пиши с номера на поръчката. Ще ти изпратим нова или ще върнем парите до 5 работни дни. / end_turn, 48

Съжалявам! Снимай пратката и етикета / max_tokens, 10

Съжалявам! Снимай пратката и етикета / end_turn, 10

Идеята

Кеш на отговорите

Втората поправка е повторението. Ако същият въпрос е задаван преди малко, отговорът е същият: не е нужно да питаш модела пак. Това е cache-aside от урока „Кеш“: гледаш в кеша, а при пропуск питаш модела и пазиш копие.

Ключът е въпросът с малки букви и по един интервал, така „колко струва доставката? “ е същото като „Колко струва доставката?“:

# ключът на кеша: малки букви, по един интервал
def key(question):
    return " ".join(question.lower().split())

В day това са редовете с answers: попадението връща записания отговор за 5 ms и без пари. Въпрос за поръчка не се кешира. Отговорът е на един клиент, а статусът се мени.

all = day(questions, False, False, False)
row("голям модел, всички документи", all, len(questions))
budget = day(questions, True, False, False)
row("+ бюджет на токени", budget, len(questions))
cached = day(questions, True, True, False)
row("+ кеш", cached, len(questions))
print(f"от кеша: {cached.hits} от {len(questions)}")

голям модел, всички документи: 1.66 € за 1000 въпроса, средно 917 ms
+ бюджет на токени: 0.90 € за 1000 въпроса, средно 898 ms
+ кеш: 0.59 € за 1000 въпроса, средно 568 ms
от кеша: 7 от 20

7 от 20 въпроса идват от кеша. Сега пада и времето, защото попадението не чака модела.

Пробвай

Намери грешката

Колега опростява кеша. Тестовете за цена минават, а след ден клиент се оплаква, че асистентът му е казал статуса на чужда поръчка. На кой ред е грешката?

Избери реда с грешката.

Идеята

По-малък модел за лесното

Третата поправка е моделът. Малкият модел е 10 пъти по-евтин на токен и пише по-бързо. В урока за оценяването наборът показа къде се справя: цената на доставката, плащането, връщането. И къде не: срока на доставката и въпроса извън документите. Затова при него отиват само одобрените теми:

# лесните теми: тестовият набор показа, че малкият модел ги поема
EASY = ["струва", "наложен", "върна", "Mastercard"]


def pick_model(question):
    return SMALL if any(word in question for word in EASY) else LARGE

all = day(questions, False, False, False)
row("голям модел, всички документи", all, len(questions))
budget = day(questions, True, False, False)
row("+ бюджет на токени", budget, len(questions))
cached = day(questions, True, True, False)
row("+ кеш", cached, len(questions))
routed = day(questions, True, True, True)
row("+ малък модел за лесното", routed, len(questions))
print(f"при малкия модел: {routed.on_small} от {len(questions)}")
month(all, len(questions))
month(routed, len(questions))

голям модел, всички документи: 1.66 € за 1000 въпроса, средно 917 ms
+ бюджет на токени: 0.90 € за 1000 въпроса, средно 898 ms
+ кеш: 0.59 € за 1000 въпроса, средно 568 ms
+ малък модел за лесното: 0.35 € за 1000 въпроса, средно 376 ms
при малкия модел: 6 от 20
месец при 3000 въпроса на ден: 149.08 €
месец при 3000 въпроса на ден: 31.75 €

Месецът пада от около 149 € до около 32 €, а средното време от 917 до 376 ms. Числата са от примерни цени и примерна формула, но редът на подобренията е истински.

Виж го

Сметката, поправка по поправка

def day(questions, budget, cache, route):
    answers = {}
    euro, ms, hits, on_small = 0.0, 0, 0, 0
    for question in questions:
        k = key(question)
        # попадение: без модел
        if cache and k in answers:
            hits += 1
            ms += CACHE_MS
            continue
        model = pick_model(question) if route else LARGE
        docs = relevant(question) if budget else ALL_DOCS
        max_tokens = 200 if budget else 1024
        msg = {"role": "user", "content": question}
        r = CLIENT.create(model=model,
                          max_tokens=max_tokens,
                          system=PROMPT + " " + docs,
                          messages=[msg])
        m = MODELS[model]
        euro += cost(m, r.usage)
        ms += latency(m, r.usage)
        if model == SMALL:
            on_small += 1
        # поръчката е на един клиент: не се кешира
        if cache and "поръчка" not in k:
            answers[k] = r.text
    return Totals(euro, ms, hits, on_small)

Стъпка по стъпка, с думи

Едно извикване: промптът, всички документи и въпросът влизат (314 токена), отговорът излиза (32). Документите са по-голямата част от сметката: 0,00177 €.
Бюджетът на токени: само разделът, за който пита въпросът, и таван за отговора. 124 токена вход, 0,00101 € за същия отговор.
Ден от 20 въпроса, на 1000 въпроса: 1,66 € с всички документи, 0,90 € с бюджета. Времето почти не мърда: то е най-вече отговорът.
Кешът: 7 от 20 въпроса са повторение и не стигат до модела. Въпрос за поръчка не се кешира.
Малкият модел поема лесните теми, които тестовият набор одобри: 6 от 20 въпроса. Той е по-евтин и по-бърз.
От 1,66 € до 0,35 € за 1000 въпроса (79% по-малко) и от 917 до 376 ms. Цените и времената са примерни.

Идеята

Пусни при теб

Истинският отговор казва колко токена е използвал. Ето заявката с бюджета за въпроса за доставката и отговора. Текстът и бройките са от фалшивия клиент:

{
  "model": "<името на модела>",
  "max_tokens": 200,
  "system": "<системният промпт>",
  "messages": [
    {
      "role": "user",
      "content": "Колко струва доставката?"
    }
  ]
}

{
  "content": [
    {
      "type": "text",
      "text": "Доставката до адрес е 4,90 €, до офис 3,50 €, а над 50 € е безплатна."
    }
  ],
  "stop_reason": "end_turn",
  "usage": {
    "input_tokens": 124,
    "output_tokens": 32
  }
}

Полетата са usage.input_tokens и usage.output_tokens, а stop_reason казва дали отговорът е цял (end_turn) или таванът го е отрязал (max_tokens). С тях програмата смята същата сметка като тук, само че с истински бройки.

Доставчиците имат официални SDK-та за Java, C#, Python и JavaScript със същата форма: съобщения, роли, токени, инструменти. Точните имена на класовете и методите са в документацията на доставчика. Тук заявката е пратена със стандартния HTTP клиент на езика, без SDK. Адресът и моделът са заместители:

import json
import os
import urllib.request

# само за показ: адресът и заглавката за ключа са в документацията на доставчика
ENDPOINT = "https://<доставчик>/..."


def ask(system, question):
    body = {
        "model": "<името на модела>",
        "max_tokens": 200,
        "system": system,
        "messages": [{"role": "user", "content": question}],
    }
    request = urllib.request.Request(
        ENDPOINT,
        data=json.dumps(body).encode("utf-8"),
        headers={
            "content-type": "application/json",
            "authorization": "Bearer " + os.environ["LLM_API_KEY"],
        },
    )
    with urllib.request.urlopen(request) as response:
        return json.load(response)  # JSON: content, stop_reason, usage


reply = ask(PROMPT + " " + relevant(question), question)
usage = reply["usage"]
print(reply["stop_reason"], usage["input_tokens"], usage["output_tokens"])

Този код не се пуска в проверката на сайта. Ключът е в променливата на средата LLM_API_KEY, а не в кода (урокът „Тайни в кода и в git“), ти трябва акаунт при доставчик и всяко пускане струва пари.

urllib.request и json са от стандартната библиотека, json.dumps прави от речника JSON.

Идеята

Кога вреди

Бюджет, който реже нужното. Ако relevant пропусне раздела с отговора, моделът казва „Не знам“ или, по-лошо, измисля. Твърде нисък max_tokens дава половин отговор. Всяка смяна на бюджета минава през тестовия набор.
Кеш, който лъже. Цената на доставката се сменя, а кешът дава старата. Кешът има срок (TTL) и се трие, когато документите се сменят. Отговори, които зависят от клиента или от времето, не влизат в него.
Малък модел без набор. „Изглежда по-просто“ не е довод. Малкият модел поема тема само след като наборът я е минал, и наборът се пуска пак при всяка смяна.
Пестене, което не си струва. Ако асистентът получава 50 въпроса на ден, сметката е няколко евро на месец. Сложността на кеша и на рутера може да струва повече от тях. Първо мери.

По-точно, за любопитните

Кеш на началото на промпта. Много доставчици пазят повтарящото се начало на промпта (системния промпт и документите) и таксуват повторното му четене по-евтино. Това е друг кеш: моделът пак отговаря, но входът е по-евтин. Той работи, ако началото е еднакво до последния символ, затова променливите части (въпросът, името на клиента) са накрая.

Кеш по смисъл. „Как да върна стоката?“ и „До кога мога да върна стоката?“ са различни ключове. Кеш с вектори (урокът за векторите) ги смята за един въпрос. Той намира повече попадения, но и грешни: „Мога ли да върна обувки?“ и „Мога ли да върна подарък?“ са близки, а отговорите може да са различни.

Поточен отговор. Отговорът може да идва дума по дума (streaming). Общото време е същото, но клиентът вижда първите думи след стотина ms вместо след секунда. Това е бързина за човека, не за сметката.

Партиди. Работа, която не чака клиент (обобщение на 10 000 отзива през нощта), може да мине през партиден режим: по-бавно и по-евтино.

Времето в продукция. Средното време крие опашката: 95% от отговорите може да са под секунда, а 5% над 5 секунди. Мери процентили, както в урока „Нефункционални изисквания, които се мерят“ от „Софтуерно инженерство“. Самото следене на цената и времето в продукция е част от MLOps и се учи в ZeroToOps.

" ".join(question.lower().split()) разделя по всякакви интервали и слепва с по един.

Упражнение

Коя поправка пести най-много

Реши задачата в редактора си.

Програмата пуска поправките натрупано, затова не се вижда колко дава всяка сама. Пусни day три пъти, всеки път само с един флаг, и отпечатай редовете до този без поправки:

голям модел, всички документи: 1.66 € за 1000 въпроса, средно 917 ms
само бюджет: 0.90 € за 1000 въпроса, средно 898 ms
само кеш: 1.06 € за 1000 въпроса, средно 580 ms
само малък модел: 0.82 € за 1000 въпроса, средно 544 ms

Сам по себе си най-евтин е малкият модел, а бюджетът е малко след него. Бюджетът почти не пести време, а кешът и малкият модел го смъкват най-много, защото не чакат големия модел да пише. Трите пестят от различни места, затова заедно дават най-много.

Още задачи

Още една лесна тема. Добави „работи“ в лесните теми. С колко пада цената? Какво трябва да направиш, преди да го пуснеш? (Подсказка: урокът за оценяването.)
Таван за деня. Спри да питаш големия модел, когато цената за деня мине 0,01 €, и отговаряй „Ще те свържа с колега“. Колко въпроса остават без отговор от модела?

Тест

Провери се

1. Въпросът е 6 токена, а сметката на извикването е за 314 токена вход. Откъде са останалите?От системния промпт и документите, които се пращат с всеки въпросОт отговора на моделаОт ключа за API-то

2. Бюджетът на токени свали цената почти наполовина, а средното време почти не мръдна. Защо?Времето не зависи от токенитеВремето е най-вече генерирането на отговора, а отговорът е същият. Входът се чете много по-бързоБюджетът забавя модела

3. Кой въпрос не бива да отива в кеша на отговорите?„Колко струва доставката?“„Кога работи поддръжката?“„Къде ми е поръчката?“: отговорът е на един клиент и се мени с времето

4. Как избираш кои въпроси да поеме малкият модел?Всички въпроси до 10 думиНа случаен принцип, половинатаПо тестовия набор: само темите, в които малкият минава всички случаи

5. max_tokens е 10, а отговорът трябва да е 30 токена. Какво получаваш?Грешка и нищо не се плащаОтрязан отговор и stop_reason „max_tokens“Моделът сам съкращава отговора така, че да е цял

Цена и бавност: бюджет, кеш, по-малък модел

Бисквитки