От OCR к LLM и обратно: как читать чеки


Мультимодальная LLM в продакшене на собственном Kubernetes-кластере: ради приватности и предсказуемых расходов

Вы отправляете скриншот банковского перевода в чат LINE. Через мгновение это уже транзакция в вашем бюджете: сумма, дата и, если получилось понять, категория. Никто ничего не печатал.

Вот и вся фича. За ней работают три «читателя»: QR-код даёт референс, которому можно доверять, OCR на Tesseract даёт быстрый первый ответ, а self-hosted мультимодальная модель дописывает остальное. Она работает на CPU в моём собственном Kubernetes-кластере: без GPU и без сторонних AI API. До этого я дошёл через несколько архитектур, нагрузочный тест, бенчмарк на 20 моделях и кучу синтетических слипов. Каждый шаг решал одну проблему и подсвечивал следующую.

Идея

JodRubJai — приложение для личных финансов: веб, Android и чат-боты в LINE и Telegram, на английском, тайском и русском. Я единственный инженер в команде из двух человек. Попробовать можно на jodrubjai.com.

В Таиланде большинство повседневных платежей — переводы PromptPay, и каждый перевод заканчивается слипом: скриншотом из банковского приложения. Эти скриншоты у людей уже есть. Поэтому план был простой. Загрузил слип — получил транзакцию.

Чат был важен не меньше приложения. В Таиланде LINE — это место, куда уже приходят банковские уведомления: у банков есть свои аккаунты в LINE, и они присылают сообщение о каждой транзакции. Это был пример для подражания, а не то, что надо разбирать: если банки говорят с людьми в LINE, то и финансовому приложению там место. Слипами люди ещё и обмениваются друг с другом в LINE. Так что LINE-бот вышел вместе с веб-приложением и первым парсером: отправил слип — получил сохранённую транзакцию. Telegram появился позже, для тех, кто не пользуется LINE, и многие из них русскоязычные. К тому времени код чатов был общим, так что это в основном был новый адаптер. Бот для Messenger тоже написан, но пока не запущен: правила Meta для ботов становятся всё строже.

Требования:

  • Быстро. Транзакция на экране сразу после загрузки. В LINE это жёсткое правило, а не приятная мелочь. Ответ бесплатный, но использует одноразовый токен, который быстро протухает. Push — сообщение, которое бот отправляет сам, — считается в месячной квоте: 300 на бесплатном тарифе. Поэтому на каждый слип приходится один быстрый ответ, и ничего не отправляется позже.
  • Везде. С самого начала веб и LINE-бот, затем Android, отслеживаемая папка, меню «Поделиться» на телефоне и Telegram.
  • Вместе с партнёром. Пары связывают аккаунты, так что слип одного может попасть в общий бюджет.
  • Без ручной работы. Никакого перепечатывания и «проверьте, пожалуйста, эти 8 полей».

Шаг 1: что внутри QR?

На каждом тайском банковском слипе есть маленький QR-код. Первая мысль: декодировать и готово. Ни OCR, ни AI.

QR — это строка EMVCo TLV: двузначный тег, двузначная длина, значение и CRC в конце. Одной спецификации мне было мало. Open-source библиотека на JavaScript promptparse уже умеет читать и собирать тайские QR-пейлоады, и я с её помощью сгенерировал первые эталонные примеры. У моего декодера на Python с первого дня был заведомо правильный ответ для сверки. Вот синтетический пейлоад:

00 38                         шаблон
   00 06 000001               маркер проверки слипа
   01 03 002                  код банка-отправителя
   02 17 DEMOREF0000000001    референс транзакции
51 02 TH                      страна
91 04 511F                    CRC-16/CCITT-FALSE

Только код банка и референс транзакции. Ни суммы, ни даты, ни имён. Подробности лежат на стороне банка, за API проверки слипов. Я хотел, чтобы приложение работало по одному скриншоту, без внешнего запроса на каждый слип, поэтому API остался за рамками.

QR платежа PromptPay содержит сумму, но это запрос на оплату, а не доказательство перевода. Парсер такие отвергает.

Итак, QR хорош в одном: это уникальный ID с контрольной суммой. Всё остальное мне пришлось читать с картинки.

Шаг 2: OCR для данных, QR для дубликатов

Первый парсер изображений совмещал оба подхода. QR (через pyzbar) давал референс, а Tesseract (тайский + английский) читал сумму и дату. Если не хватало любого из трёх, загрузка считалась неудачной. Референс стал ключом дедупликации, закреплённым уникальным ограничением: загрузишь один слип дважды — получишь ту же транзакцию.

Позже повторная загрузка слипа стала обновлять транзакцию более новым и лучшим парсером. Заметка или категория заполняется, только если она пустая, а транзакцию, которую пользователь заблокировал, не трогают вообще.

Потом бенчмарк (шаг 7) показал, что маленькая мультимодальная модель теряет символы, когда читает печатный референс: девять нулей превратились в пять. Неверный референс хуже, чем никакого. Теперь референс берётся только из QR с проверенным CRC, а чеки без QR дедуплицируются по SHA-256 файла.

Шаг 3: тестируем OCR на синтетических чеках

Настоящие слипы содержат имена, номера счетов и суммы. В git-репозиторий им нельзя, и в логах CI я их тоже не хочу.

Поэтому я написал генератор. Он рисует синтетические тестовые слипы в стиле раскладки каждого банка: демо-имена вроде «MR. DEMO USER», выдуманный референс и QR, который корректно декодируется, но не указывает ни на какой настоящий перевод:

Синтетический тестовый слип. Все имена, числа и QR на нём выдуманы.
Синтетический слип

Рядом с каждой картинкой генератор записывает эталонную разметку из тех же значений, которые только что нарисовал:

amount: '1234.56'
currency: ''
note: Coffee with friends
occurred_at: 2026-01-15 09:00
recipient: MS. DEMO RECIPIENT
sender: MR. DEMO USER
slip_ref: DEMOREF0000000001

Разметка и пиксели получаются из одного вызова функции, поэтому разойтись они не могут. Руками ничего не правится: поменял рендерер — перегенерировал.

Корпус покрывает водяные знаки, подписи на тайском и английском, комиссии и странные форматы дат. Когда настоящий слип не парсился, исправление приходило вместе с его синтетическим вариантом.

Шаг 4: пакетная загрузка и первый нагрузочный тест

Когда одиночная загрузка заработала, следующая фича напрашивалась сама. У людей не один слип. У них целая папка. Так что дальше пришла пакетная загрузка, а за ней автозагрузка из папки: даёшь доступ к папке один раз, и новые скриншоты из неё импортируются сами.

Это породило вопрос раньше, чем его задал кто-то из пользователей: что будет, если загрузить всё сразу? У меня больше 2 900 собственных слипов, так что реалистичный тестовый набор был.

Инструмент — k6. Каждый виртуальный пользователь входит в свой аккаунт и в цикле загружает мои слипы; нагрузка растёт, держится и спадает. Тест шёл против моего локального кластера kind, который использует те же манифесты, что и продакшен, но перед каждым прогоном они патчились под один вариант набора реплик, воркеров gunicorn и CPU.

Что я считал:

  • Ошибки прокси: ответы 502, 503 или 504. Это сигнал «сломалось»: прокси перестал ждать, а бэкенд так и не ответил.
  • Задержку загрузки запроса parseReceipt: медиана, p95, максимум.
  • Прочие сбои, как перекрёстная проверка, чтобы сломанный логин не выдал себя за «быстрый» прогон.

Последнее оказалось важным. По умолчанию k6 сбрасывает куки между итерациями, так что мои первые прогоны загружали слипы без авторизации и получали 403: быстро, чисто и бессмысленно. Помог noCookiesReset.

С тогдашними настройками продакшена тест провалился. OCR упирается в CPU и выполнялся внутри запроса, так что загрузки вставали в очередь за воркерами, и прокси в итоге отвечал ошибкой, не дождавшись бэкенда.

Потом я перебрал несколько конфигураций, и тест подтвердил то, чего я ждал: больше воркеров gunicorn на том же CPU делало хуже, потому что воркеры, упирающиеся в CPU, просто дерутся за ядра. Одних только реплик тоже было мало. Нужно было и то и другое: больше подов и по одному воркеру на ядро в каждом.

Шаг 5: каждый банк печатает слип по-своему

Потом пошли слипы других банков. В Таиланде банк часто называют по цвету, а не по названию, и в коде я делал так же: зелёный, фиолетовый и жёлтый. Никаких брендов, а генератор рисует похожие слипы, а не копии.

  • Зелёный и фиолетовый печатают подписи «от кого» и «кому», на тайском или английском.
  • Жёлтый не печатает подписей вообще: два блока с именами и стрелка.
  • Фиолетовый слип на тайском пишет дату как 15 มกราคม 2569 - 09:00. Моя регулярка не ожидала тире и молча записывала полночь. Ни ошибки, просто правдоподобный неверный ответ.
  • Водяные знаки протекали в текст. Один раз иконку банка прочитали как часть имени получателя.
  • У некоторых слипов вообще нет QR. Нет QR — нет референса, и OCR остаётся единственным источником данных.
  • А на одном слипе из моей коллекции рядом с деталями перевода был целый билет в кино: много текста, который выглядит как данные, но ими не является.

Каждое исправление было эвристикой под один настоящий слип, и они копились. Тогда я заменил эту кучу одной таблицей правил: поле, его ключевые слова-якоря и режим извлечения. Новая раскладка стала новой строкой в таблице, а не новой веткой кода.

Этого всё равно не хватило. Tesseract требовал двух проходов и всё более банк-специфичной подстройки. Классические альтернативы тоже не подошли: для PaddleOCR не было wheel под нашу версию Python, а EasyOCR прочитал 0 из 17 настоящих слипов и работал примерно в 48 раз медленнее. Из подписи «кому», которая напечатана как TO, он сделал gto. Готов к труду и обороне, не иначе.

Шаг 6: переход на LLM и приватность

Tesseract был лучшим из классических инструментов, и этого всё равно не хватало. Всё умнее означало глубокое обучение и PyTorch, а на этом месте это уже почти LLM. Поэтому я сменил стратегию и пошёл до конца: мультимодальная языковая модель, которая смотрит на изображение и возвращает JSON.

Очевидный путь — облачный API. Я его не выбрал. Слип показывает, кому вы платите, сколько и когда. Для финансового приложения это самые чувствительные данные. Я не хотел, чтобы каждое фото уходило третьей стороне, по той же причине, по которой отказался от API проверки слипов. Поэтому модель работает внутри моего собственного Kubernetes-кластера. В уведомлении о приватности это сказано прямо: чеки «никогда не отправляются в сторонние AI-сервисы», и ими не обучают никакие модели.

Фото хранится 15 дней, и это сделано намеренно. Если выйдет модель получше или правка промпта починит какое-то поле, свежие чеки можно прочитать второй раз. После этого фото удаляется; остаётся только его хеш для дедупликации.

Первая версия на LLM — Gemma 4 E2B на Ollama, один вызов на все поля. Она читала поля, с которыми Tesseract мучился, и открыла дверь: чеки из магазинов любой страны, а не только тайские слипы. Синтетический корпус вырос вместе с ними, в него вошли чеки в USD, EUR и JPY. Но вызов сидел внутри запроса на загрузку. На CPU в кластере он занимал 20–30 секунд, и это стало задержкой каждой загрузки. Для LINE-бота этого достаточно, чтобы потерять окно для ответа.

Шаг 7: настраиваем LLM

Сначала я сделал бенчмарк: настоящий код парсинга поверх размеченного корпуса, точность по каждому полю и задержка. Два корпуса: 20 синтетических слипов и 50 моих собственных настоящих чеков за 2019–2025 годы, которые никогда не покидают мою машину. Всё это шло на ноутбуке, в том же локальном кластере, в котором я разрабатываю: около 20 часов прогонов. Каждое число ниже — доля по повторным прогонам, потому что даже при temperature: 0 одна и та же модель на CPU не всегда даёт один и тот же ответ дважды.

Что я выяснил:

  • Проси у маленькой модели меньше за раз. Описания полей в JSON-схеме заставляли модель путать значения между полями, а одно лишнее поле сбивало поля, которые до этого были стабильны. Так стратегией стало многопроходное извлечение: несколько коротких вопросов про один и тот же чек вместо одного длинного.
  • Режим рассуждений съедает бюджет. Gemma 4 по умолчанию «думает». Это расходовало выходные токены до начала ответа и стоило около 40 с на чек. reasoning_effort: "none" — не тюнинг. Это обязательное условие.
  • Разрешение картинки решает судьбу тайских имён. При 280 токенах на изображение модель читала тайскую букву ด как ต на каждой картинке с тайским именем. При 560 читала правильно, а задержка выросла примерно на 5%.
  • Правила в промпте помогают, а потом перестают. Переработка промпта подняла получателя с 60% до 83% на синтетических слипах. Отправителя в промпте не сдвинуло ничего: это был предел модели, и исправила его только модель побольше, о ней ниже.

Переход с Ollama на llama-server из llama.cpp примерно вдвое снизил память и открыл настройку токенов на изображение. Это сделало практичной модель побольше, Gemma 4 E4B:

50 настоящих чеков заметка отправитель получатель
Ollama, Gemma 4 E2B 28% 8% 60%
llama-server, Gemma 4 E4B, 560 токенов на изображение 100% 83% 79%

Сумма, дата и референс читаются на 100% в обоих случаях. Референс берётся только из QR; у чека без QR-кода его, как и задумано, нет. Модель только переписывает текст; в числа и даты его превращает протестированный код.

Сам клиент намеренно скучный. Без агентных фреймворков и tool calling: на каждый вопрос уходит ровно один HTTP-запрос. У маленькой модели маленький контекст, и каждый токен инструкций, схем инструментов или служебного текста фреймворка отнимает место у картинки. В упрощённом виде:

def ask(image_png: bytes, prompt: str, keys: list[str]) -> dict:
    """Один вопрос про один чек. Упрощено из receipts/parsers/vlm.py."""
    data_uri = "data:image/png;base64," + base64.b64encode(image_png).decode()
    response = requests.post(
        f"{VLM_BASE_URL}/chat/completions",       # любой OpenAI-совместимый сервер
        json={
            "model": VLM_MODEL,
            "messages": [{"role": "user", "content": [
                {"type": "text", "text": f"{prompt} Reply with ONLY a JSON "
                                         f"object with these keys: {', '.join(keys)}."},
                {"type": "image_url", "image_url": {"url": data_uri}},
            ]}],
            "response_format": {"type": "json_object"},
            "reasoning_effort": "none",   # Gemma 4 по умолчанию «думает»
            "temperature": 0,
            "max_tokens": 1024,
        },
        timeout=180,
    )
    response.raise_for_status()
    return json.loads(response.json()["choices"][0]["message"]["content"])

Поскольку он говорит на обычном OpenAI-совместимом API, переезд с Ollama на llama-server свёлся к смене URL и названия модели, а не кода.

Шаг 8: self-hosting модели

Self-hosting звучит как «запусти контейнер». На практике это оказался список мелких ловушек.

GPU нет. Всё работает на CPU, а модель через nodeSelector закреплена за нодой, где хватает памяти.

Как выглядит деплой, сокращённо:

initContainers:
  - name: fetch-model          # скачать один раз на PVC, проверить, в следующий раз пропустить
    image: docker.io/curlimages/curl:8.11.1
    env:
      - { name: HF_REPO,      value: unsloth/gemma-4-E4B-it-GGUF }
      - { name: HF_REVISION,  value: <pinned commit> }
      - { name: MODEL_FILE,   value: gemma-4-E4B-it-Q4_K_M.gguf }
      - { name: MODEL_SHA256, value: <sha256> }
    command: ["/bin/sh", "-c"]
    args:
      - |
        set -eu; cd /models
        # уже на месте и целый? тогда этот старт стоит одного чтения хеша
        if echo "$MODEL_SHA256  $MODEL_FILE" | sha256sum -c - >/dev/null 2>&1; then exit 0; fi
        curl -fL --retry 5 -o "$MODEL_FILE.part" \
          "https://huggingface.co/$HF_REPO/resolve/$HF_REVISION/$MODEL_FILE"
        echo "$MODEL_SHA256  $MODEL_FILE.part" | sha256sum -c -   # не тот файл: под падает
        mv "$MODEL_FILE.part" "$MODEL_FILE"
    volumeMounts:
      - { name: models, mountPath: /models }          # веса пишутся сюда
containers:
  - name: llama-server
    image: ghcr.io/ggml-org/llama.cpp@sha256:<digest>   # официальный образ, закреплён
    args: [-m, /models/gemma-4-E4B-it-Q4_K_M.gguf, --mmproj, /models/mmproj-BF16.gguf,
           -np, "2", -c, "8192", --image-max-tokens, "560",
           --cache-ram, "0", --metrics]
    env:
      - name: LLAMA_ARG_THREADS                       # число потоков следует лимиту CPU
        valueFrom: { resourceFieldRef: { resource: limits.cpu } }
    volumeMounts:
      - { name: models, mountPath: /models, readOnly: true }
    resources:
      requests: { cpu: "2", memory: 8Gi }
      limits:   { cpu: "4", memory: 12Gi }
    # /health отвечает 503, пока модель грузится; занятый CPU может задержать ответ дольше 1 с
    startupProbe:
      httpGet: { path: /health, port: 8080 }
      periodSeconds: 10
      timeoutSeconds: 10
      failureThreshold: 60    # 60 × 10 с: до 10 минут на загрузку (скачивание уже прошло в init-контейнере)
    livenessProbe:
      httpGet: { path: /health, port: 8080 }
      periodSeconds: 20
      timeoutSeconds: 10      # дефолтная 1 с убила здоровый сервер посреди чека
      failureThreshold: 6
volumes:
  - name: models
    persistentVolumeClaim: { claimName: llama-server-models }

Ловушки, которые стоят за этими строками:

  • Не запекай веса в образ. Сборка образа с примерно 6 ГБ весов требовала около 25 ГБ временного диска. Init-контейнер скачивает их с закреплённого коммита Hugging Face, проверяет SHA-256 и сохраняет их на постоянный диск (PVC). Оборванная загрузка падает с шумом, а не подсовывает другую модель.
  • Кэш, которым не пользуются, всё равно растёт. llama-server по умолчанию хранит старые промпты в RAM для повторного использования. Каждый чек — новая картинка, так что переиспользовать нечего. После длинного прогона бенчмарка на ноутбуке под занимал 11,8 ГБ. С --cache-ram 0 он держится около 3,8 ГБ плюс веса.
  • Занятая модель выглядит мёртвой. Генерация загружает все ядра, и health-эндпоинт может отвечать дольше секунды. С пробами по умолчанию Kubernetes перезапустил абсолютно исправный сервер модели прямо посреди разбора чека. Теперь пробы ждут 10 секунд.
  • Больше слотов не значит быстрее. На CPU четыре параллельных слота почти не подняли пропускную способность и замедлили каждый запрос. Я запускаю два, и причина в следующем шаге.
  • У сервера нет аутентификации. NetworkPolicy пускает только неймспейс приложения и Prometheus.

Реплика одна, а стратегия раскатки — Recreate: две копии потребовали бы вдвое больше памяти. Так что обновление модели — это короткий простой, и его сглаживают повторные попытки Celery. Деплой идёт через Flux, как и всё остальное в кластере.

А модель расходов простая. Нет счёта за чек или за токен, нет GPU. Я плачу за VPS или за ноду Kubernetes, в которой хватает RAM, чтобы держать модель. Тысяча чеков или сто тысяч, счёт один и тот же; растёт только очередь. Если очередь становится слишком длинной, я добавлю ещё одну ноду с ещё одной копией модели. А чтобы было дешевле, в планах эластичные ноды: поднимаются, когда очередь растёт, и убираются, когда она пуста, так что я плачу за время модели только тогда, когда есть работа.

Шаг 9: обратно к OCR, а LLM уходит в фон

Модель стала хорошей, но всё ещё 20–30 секунд на CPU. Поэтому я вернул Tesseract. Не как парсер, а как быстрый первый проход:

  1. В запросе: сохранить фото, декодировать QR, прогнать один проход Tesseract. Он берёт всё, что может (референс из QR, сумму, дату, заметку), но обязательна только сумма. Транзакция появляется сразу.
  2. В задаче Celery: мультимодальная модель читает то же сохранённое фото и дописывает отправителя, получателя, заметку, валюту и точное время. Если первый проход ничего не нашёл, задача сама делает полный разбор.

У фонового прохода есть подвох: пользователь может отредактировать транзакцию, пока модель её читает. Поэтому задача пишет условным UPDATE, который срабатывает, только если с момента загрузки ничего не менялось. Иначе её результат становится предложением, которое пользователь просматривает по полям.

Ответ в LINE несёт результат OCR; улучшения от модели появляются в приложении.

Отдельная история — массовый импорт. Кто-то загружает слипы за несколько лет сразу, как мои 2 900. Каждый — задача для модели на 20–30 секунд в очереди по умолчанию. Сообщение в LINE, ждущее позади них, пережило бы свой токен ответа, и пользователь не получил бы ответа вовсе. Поэтому у задач чата появились своя очередь chat и свой воркер. У сервера модели два слота, общие для обоих воркеров: во время большого импорта вопрос из чата ждёт самое большее одного прочитанного чека, а не всего импорта.

Весь пайплайн сегодня:

flowchart LR
    subgraph In["Откуда приходят слипы"]
        App["Web / Android-приложение<br/>(также отслеживаемая папка, меню «Поделиться»)"]
        Bot["Бот LINE / Telegram"]
    end

    App -- "parseReceipt" --> API["Бэкенд<br/>(GraphQL)"]
    Bot -- "webhook" --> CQ[["очередь chat"]]
    CQ --> CW["Воркер чата"]

    API --> Fast
    CW --> Fast
    Fast["Быстрый проход<br/>фото · QR · Tesseract<br/>сумма обязательна"] --> Tx[("Транзакция<br/>источник: OCR")]
    CW -- "один бесплатный ответ" --> Bot

    Fast -- "в очередь" --> DQ[["очередь default"]]
    DQ --> RW["Воркер чеков"]
    subgraph VLM["llama-server · Gemma 4 E4B · только CPU<br/>2 слота, общие: запрос берёт любой свободный"]
        S1["слот 1"]
        S2["слот 2"]
    end
    RW -- "чтение чеков, 20–30 с" --> VLM
    CW -. "вопросы из чата, короткие" .-> VLM

    RW --> Changed{"Менялось после<br/>загрузки?"}
    Changed -- "нет" --> Tx2[("Транзакция<br/>источник: LLM")]
    Changed -- "да" --> Review["Предложение,<br/>просмотр по полям"]

Результаты

Событие Первый парсер Сейчас
Что нужно для создания транзакции референс + сумма + дата только сумма
Нечитаемое фото загрузка падает фоновая модель всё равно пробует
Отправитель / получатель сопоставление подписей OCR мультимодальная модель
Вызов модели нет асинхронно, вне пути запроса
Правка во время обработки н/д конфликт, который можно разобрать
Хранение фото не хранится 15 дней
Хостинг модели нет свой кластер, только CPU, без внешнего API

На 50 настоящих чеках сумма, дата и референс читаются в 100% случаев (без референса, когда QR-кода нет, как и задумано). Первое чтение настоящего фото моделью занимает около 20 секунд, но никто его не ждёт.

Одна проблема остаётся открытой: имена, написанные тайскими буквами. Если те же 50 настоящих чеков разбить по письменности, имя отправителя на латинице модель читает верно в 95% случаев, а на тайском только в 11%. Больший бюджет на изображение не помог. Из 20 протестированных мной моделей хоть какого-то тайского отправителя прочитали только две, и с задержкой в 6–8 раз больше. А общий результат по отправителю, 83% (см. таблицу в шаге 7), усреднил оба случая и скрыл этот провал. Вывод для вас: если в документах встречаются разные письменности, считайте точность для каждой из них отдельно. Среднее по полю этого не покажет.

Чему это меня научило

Не список ошибок. Скорее способ прийти к результату, который работает.

  • Соотноси потребности с возможностями. Облачный API или GPU были бы проще. У меня были CPU, обещание приватности и один инженер — я. Поэтому: маленькая модель, короткий промпт и OCR для той части, которая должна быть быстрой.
  • Итерируй, не жди идеала. Каждая версия выходила и чему-то меня учила: QR, OCR, таблица правил, модель в запросе, два прохода. Бенчмарк появился тогда, когда угадывания стало мало, а не до первой строки кода.
  • Отойди и оглянись. Возврат к OCR не был поражением. Модель читала точнее, а OCR работал быстрее. Лучше всего было взять оба, и я понял это, только когда отказался от идеи «заменить OCR на LLM».