MIT доказал, что можно удалить 90% нейросети без потери точности.

Исследователи обнаружили, что внутри каждой большой модели есть «выигрышный билет» (winning ticket) — маленькая подсеть, которая выполняет основную работу.

Они доказали: если найти её и сбросить в исходное состояние, она будет работать так же, как и вся большая модель.

Но был нюанс, который сразу убил практическое применение…

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

Оригинальная статья 2018 года была по-настоящему впечатляющей.

Но сегодня, спустя 8 лет… мы наконец получили прорыв на уровне железа: структурированная разреженность

Современные GPU (NVIDIA Ampere и новее) больше не просто «эмулируют» прунинг.

У них есть нативная поддержка блочной разреженности (паттерны 2:4), встроенная прямо в железо.

Это не теория — это ускорение на уровне силикона.

Математика выглядит очень убедительно: сеть с 90% разреженности = на 50% меньше пропускной способности памяти + 2× пропускная способность вычислений. Реальное ускорение без потери точности.

Три фактора сделали это готовым к продакшену в 2026:

- обучение с учётом прунинга (модель изначально обучается разреженной)
- нативная поддержка в PyTorch 2.0 и Apple Neural Engine
- понимание того, что AI-модели по своей природе на 90% избыточны

Эволюция переусложняет системы. Мы наконец научились их «прореживать».

Эпоха раздутых и неэффективных моделей официально закончилась. Инструменты наконец догнали теорию, и выигрывать будут те, кто перестанет платить за 90% весов, которые им не нужны.

Будущее AI — это более компактные, быстрые и эффективные модели.

👉 @DataSciencegx

Это уже следующий уровень.

MegaTrain: > LLM с 100B+ параметров, обученные на одной GPU

Это будет только развиваться.

В недалёком будущем…

У каждого человека будет свой персональный GPU с персональным сверхинтеллектом, который он обучил у себя дома.

👉 @DataSciencegx

Flash Attention — серия: разбор Softmax

Flash Attention — один из ключевых современных алгоритмов attention. В его основе лежит online softmax, и понимание этого механизма сильно упрощает понимание Flash Attention.

В PyTorch softmax определяется как функция, применяемая к N-мерному тензору, где выходной тензор нормализуется в диапазон [0, 1], а сумма всех элементов равна 1.

Читать статью

👉 @DataSciencegx

NVIDIA и Unsloth выпустили одно из лучших практических руководств по созданию RL-окружений с нуля, закрывая пробелы, которые пропускает большинство туториалов.

Включает:

- Почему RL-окружения важны + как их строить
- Когда RL превосходит SFT
- Лучшие практики GRPO и RL
- Как работают проверяемые награды и RLVR

https://unsloth.ai/blog/rl-environments

👉 @DataSciencegx

Полное глобальное внимание vs чередующееся внимание, визуальное объяснение:

👉 @DataSciencegx

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

Случайно наткнулся на опенсорс-проект под названием MathCode. Он принимает описание математической задачи на естественном языке и автоматически конвертирует его в теоремы для Lean 4, после чего пытается завершить формальное доказательство.

Проще говоря, это ассистент для доказательства теорем прямо в терминале. Вводишь фразу вроде «Докажи, что квадрат чётного числа — чётный», и он сам проходит весь пайплайн: от формализации до доказательства.

Также есть интеграция с Lean LSP, которая позволяет автоматически подтягивать существующие леммы из библиотеки Mathlib для помощи в доказательствах. Если возникают ошибки компиляции, система автоматически их исправляет и делает ретраи, до десяти итераций.

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

Если интересна формальная верификация математики или вы используете Lean 4 и считаете ручной процесс слишком трудоёмким, этот инструмент стоит попробовать.

👉 @DataSciencegx

Технический вопрос на собеседовании по большим языковым моделям:

У вас есть 80 000 траекторий агента из продакшена. Нужно выбрать те, которые стоит отправить на ревью, чтобы улучшить агента.

Использовать большие языковые модели для оценки траекторий нельзя. Как будете решать задачу?

Самый простой вариант — случайная выборка. Берём 100 случайных траекторий и отдаём их на ручное ревью. Но в продакшене агенты обычно нормально обрабатывают типовые запросы, поэтому значительная часть бюджета аннотации уходит на шум.

Другой подход — фильтровать длинные диалоги, предполагая, что 10+ сообщений пользователя означают более сложный сценарий. Но длинные диалоги сильно смещены в сторону явных фейлов. В итоге вы находите очевидные сбои и пропускаете тонкие проблемы в сценариях, где агент формально справился.

В недавней работе от DigitalOcean предложен другой подход: вычислять лёгкие поведенческие сигналы напрямую из данных траекторий с помощью детерминированных правил поверх диалогов и логов выполнения.

Сигналы делятся на три группы:

1. Сигналы взаимодействия — из диалога пользователь–агент.
Если пользователь переформулирует один и тот же запрос или исправляет агента — это рассинхронизация. Если агент повторяется без прогресса — стагнация. Запрос оператора или прекращение диалога — потеря вовлечённости. Подтверждение, что всё сработало — удовлетворённость. Всё это определяется через нормализованное сопоставление фраз и проверку схожести соседних реплик.

2. Сигналы выполнения — из вызовов инструментов и событий рантайма.
Вызов инструмента, который возвращает пустой результат или не двигает задачу, считается фейлом. Повторяющиеся вызовы с одинаковыми или «плывущими» входами указывают на цикл. Эти сигналы легко извлекаются из структурированных логов выполнения.

3. Сигналы окружения — ограничения по частоте, переполнение контекста, ошибки API.
Полезны для диагностики, но не подходят для обучения, так как отражают ограничения системы, а не решения агента.

Каждой траектории присваивается скор на основе сработавших сигналов, после чего на ревью отправляются траектории с наибольшим сигналом.

На τ-bench сравнили три подхода на 100 траекториях:

- Случайная выборка — 54% информативности
- Эвристика по длине — 74%
- Сигнальный подход — 82%

То есть примерно 4 из 5 выбранных траекторий действительно полезны для улучшения агента.

Даже среди диалогов, где агент корректно выполнил задачу, сигнальный подход находил полезные паттерны в 66.7% случаев против 41.3% у случайной выборки.

Это скрытые проблемы: нарушения политик, неэффективное использование инструментов, лишние шаги. Задача формально выполнена, но есть потенциал для оптимизации.

Весь пайплайн работает без накладных расходов на большие языковые модели и может постоянно работать в продакшене, размечая каждую траекторию на входе.

Если нужна практическая реализация, этот подход уже интегрирован в Plano — опенсорс прокси для ИИ, который объединяет маршрутизацию, оркестрацию, защитные ограничения и наблюдаемость.

GitHub → https://github.com/katanemo/plano
Статья → https://arxiv.org/pdf/2604.00356

👉 @DataSciencegx

Растущий кеш ключей-значений в механизме внимания — ключевой компонент для работы языковых моделей с длинным контекстом. Но что ограничивает модули долговременной памяти (например, Titans)? Что если совместить сжатие контекста как у Titans с растущей памятью, как у трансформеров?

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

На основе этой идеи предлагается разреженное селективное кеширование — архитектура с эффективно растущей памятью (как у внимания), но с почти постоянной стоимостью инференса на токен (как у рекуррентных сетей).

В статье в основном рассматриваются:
(1) общая основа для механизма внимания с softmax и модулей долговременной памяти фиксированного размера (или рекуррентных нейросетей), которая позволила спроектировать архитектуру, совмещающую преимущества обоих подходов;
(2) различные варианты кеширования памяти, включая вариант, где эффективный объём памяти растёт, при этом стоимость декодирования остаётся «постоянной»;
(3) единая перспектива для понимания гибридных моделей, в которых комбинируются механизм внимания и рекуррентные модели.

👉 @DataSciencegx

безумные результаты

в цифровой логике известно, что одного вентиля NAND достаточно, чтобы собрать любую булеву схему.

AND, OR, NOT, XOR — всё сводится к NAND. Аналога для непрерывной математики, той, что используется в научных калькуляторах (sin, cos, log, exp, sqrt и т.д.), долгое время не находили.
В этой работе показано, что один бинарный оператор покрывает это:

например
eml(1, eml(eml(1, x), 1)) = ln(x)
и
eml(x, 1) = exp(x) - ln(1) = exp(x) - 0 = exp(x)

когда есть ln(x) и exp(x), всё остальное можно получить, применяя тот же оператор снова и снова

👉 @DataSciencegx

Наш слон: собрал полноценный движок инференса LLM на C#/.NET 10. С нуля. 🐘

Не обёртка — нативная загрузка GGUF, токенизатор BPE, механизм внимания, KV-кэш, SIMD-векторизованные CPU-ядра, CUDA-бэкенд для GPU, API, совместимый с OpenAI.

Один разработчик, ~2 месяца, с использованием ИИ (без вайбкодинга). Первый превью-релиз уже доступен.

Подробнее: https://kokosa.dev/blog/2026/dotllm/ и https://dotllm.dev/

👉 @DataSciencegx

Машинное обучение глазами новичка в data science

👉 @DataSciencegx

«NAND» для непрерывной математики.

Один бинарный оператор вместе с константой 1 порождает любые элементарные функции:

  eml(x, y) = eˣ − ln(y)

• e = eml(1, 1)
• eˣ = eml(x, 1)
• ln(x) = eml(1, eml(eml(1, x), 1))

Собран интерактивный ноутбук для исследования идеи: можно менять x и наблюдать, как значения распространяются по узлам в реальном времени.

https://arxiv.org/abs/2603.21852

👉 @DataSciencegx

Что если эксперименты в ML могли бы крутиться всю ночь и сохранять только те изменения, которые реально улучшают метрики?

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

Autoresearch — опенсорс-фреймворк, который решает это через автономный цикл.

Агент фиксирует каждое изменение в git, запускает обучение на ~5 минут и проверяет, улучшилась ли модель.

Если метрика выросла — изменение остаётся. Если нет — происходит откат к последнему валидному состоянию.

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

https://github.com/karpathy/autoresearch

👉 @DataSciencegx

GitHub массово выкатил инструмент, который снижает расходы на ИИ примерно на 75%.

И большинство разработчиков пока его игнорируют.

Caveman — скилл для Claude Code, который заставляет модель отвечать в максимально сжатом «пещерном» стиле.

↳ убирает весь филлер, хеджирование и вежливые формулировки
↳ сохраняет 100% технической точности
↳ снижает количество выходных токенов до ~75%
↳ автоматически возвращается к нормальному английскому для критичных предупреждений по безопасности
↳ работает как обычный скилл для Claude Code — без сложной настройки
↳ устанавливается одной строкой в проект

Почему это важно:

Основная часть затрат на ИИ уходит на «вежливость».

"I'd be happy to help you with that! Here's a comprehensive overview..."

Это ~20 токенов до начала ответа.

Caveman убирает это полностью.

На выходе — прямые, короткие, технически точные ответы без лишнего.

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

По сути, это один из самых практичных приёмов промпт-инжиниринга, упакованный в готовый скилл.

https://github.com/JuliusBrussee/caveman

👉 @DataSciencegx

Реализация нейронной сети с нуля на чистом ассемблере x86-64

Да, всё верно. Будем делать это на максимально низком уровне. В этой статье мы реализуем небольшую нейросеть для XOR на ассемблере x86-64. Без библиотек. Без упрощений. Только ты и процессор.

Требования: нужно понимать базу нейронных сетей (слои, веса, смещения, функции активации). Опыт с ассемблером будет плюсом, но по ходу будут объяснения. Понадобятся NASM и GCC, установленные на Linux-системе.

👉 @DataSciencegx

Кэширование промптов в больших языковых моделях — понятное объяснение
Кейс о том, как Claude достигает 92% cache hit-rate

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

В долгоживущих агентных воркфлоу такие избыточные вычисления часто становятся самой дорогой строкой затрат во всей ИИ-инфраструктуре.

Системный промпт на 20 000 токенов при 50 шагах — это 1 миллион токенов избыточных вычислений, оплаченных по полной цене и не создающих новой ценности. И эта стоимость накапливается для каждого пользователя и каждой сессии.

Решение — кэширование промптов. Но чтобы использовать его эффективно, нужно понимать, что именно происходит под капотом.

👉 @DataSciencegx

Техники дообучения LLM, которые стоит изучить для кастомизации:

Сохрани.

1. LoRA
2. QLoRA
3. Prefix Tuning
4. Adapter Tuning
5. Instruction Tuning
6. P-Tuning
7. BitFit
8. Soft Prompts
9. RLHF
10. RLAIF
11. DPO (прямая оптимизация предпочтений)
12. GRPO (групповая относительная оптимизация политики)
13. RLAIF (обучение с подкреплением на основе AI-фидбэка)
14. Многозадачное дообучение
15. Федеративное дообучение

Мой фаворит — GRPO для построения моделей с рассуждением. Что насчёт тебя?

👉 @DataSciencegx

Microsoft существенно сжал рассуждение в LLM.

В новой работе представлен MEMENTO — метод, при котором модель учится самостоятельно управлять своим контекстом.

Вместо того чтобы раздувать chain-of-thought в плоский поток на 32K токенов, модель сегментирует рассуждение на блоки, сжимает каждый в плотное резюме (memento) и маскирует исходный блок для дальнейшего внимания.

Результат — пилообразный паттерн KV-кэша, где память периодически уменьшается, а не растёт монотонно.

Обучение строится как двухэтапный SFT-пайплайн.

Этап 1: обучение формату блок → memento с полным вниманием.
Этап 2: обучение рассуждению с замаскированными блоками. Каждый блок сжимается в 5–20 раз, а пик KV-кэша уменьшается в 2–2.5 раза на разных моделях.

Самое интересное — эффект «двойного потока информации».

В момент генерации memento модель всё ещё видит полный блок рассуждения, поэтому KV-представления для memento считаются с учётом полного контекста блока.

После маскирования блока эти KV остаются и продолжают нести неявную информацию, которая не содержится в самом тексте memento.

Если пересчитать KV для memento без доступа к исходному блоку, точность падает примерно на 15 процентных пунктов. Тот же текст, но другие KV-представления — заметно хуже результат.

Это ключевое отличие MEMENTO от подходов, которые пересобирают контекст только из текста и теряют этот неявный канал.

Также показано, что разрыв в точности связан с согласованностью, а не со способностями модели. Она всё ещё может решать те же задачи, но менее стабильно. Голосование по нескольким ответам (k=3) восстанавливает базовую точность, а обучение с подкреплением закрывает большую часть оставшегося разрыва.

По мере роста длины рассуждений модели, которые умеют сжимать промежуточное состояние, смогут обслуживать больше пользователей на том же железе. А двойной KV-канал указывает, что маскирование «на месте» фундаментально лучше, чем подходы с перезапуском контекста.

Статья и датасет (228K трасс рассуждений) доступны публично. Ссылка

👉 @DataSciencegx

Kimi опять двигает инференс-стек.

Moonshot AI выкатили подход Prefill-as-a-Service, где стадии предзаполнения и декодирования больше не привязаны к одному кластеру. Теперь это кросс-датацентровая архитектура с гетерогенным железом, что позволяет гибко распределять нагрузку и снижать стоимость инференса.

Ключевая проблема раньше — перенос KV-кэша между узлами: слишком большой, дорогой по сети. Решение — архитектура Kimi Linear, которая уменьшает размер KV-кэша и делает такую схему практически применимой.

Что получили на практике:

* +1.54× к пропускной способности
* −64% к P90 времени до первого токена
* прямое снижение стоимости токена

Контекст: Kimi уже давно упирается в инфраструктуру, а не только в модель. У них есть собственные решения вокруг KV-кэша и дизагрегации инференса, и это логичное продолжение — вынести prefill как отдельный сервис.

Вывод: рынок движется в сторону разделения инференс-пайплайна и оптимизации под стоимость, а не только под качество модели.

👉 @DataSciencegx

Гении предложили общий кросс-доменный слой памяти для кодинг-агентов.

Эта идея называется Memory Transfer Learning (MTL).

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

→ Такая память становится общим ресурсом и универсальной библиотекой опыта для множества агентов и моделей.

Прирост (+3.7% в среднем) достигается за счёт мета-знаний:

* как валидировать решение
* как структурировать дебаг
* какие проверки запускать
* как детектить паттерны фейлов

При этом важен уровень абстракции: память, слишком привязанная к конкретной задаче, ухудшает качество.

Память для дебага, генерации кода и тестирования складывается в один общий пул. Чем больше памяти, тем лучше работает перенос.

MTL даёт агенту возможность переиспользовать общее рассуждение и проверки, а не только точные трассы решений.

https://github.com/KangsanKim07/MemoryTransferLearning
https://arxiv.org/abs/2604.14004

👉 @DataSciencegx