OpenAI Только что Поймала ИИ Думающим

Кто-то в OpenAI только что сделал то, что можно назвать аналогом извлечения процессора из эпоксидки и нахождения читаемого схемного рисунка внутри. Их новое исследование по «разреженности цепей» берет трансформер в стиле GPT-2, обучает его на коде Python и жестоко удаляет более 99.9% внутренних соединений в процессе обучения. То, что выживает, — это не размытые вероятности, а крошечные, осязаемые цепи, которые вы действительно можете проследить.

Современный дизайн языковых моделей рассматривает рассуждение как черный ящик: миллионы или миллиарды весов срабатывают одновременно, и вы видите только финальный токен. Даже когда ответ выглядит корректным, никто не может сказать, какая внимательная голова, нейрон или ячейка памяти действительно сыграли решающую роль. Работа по интерпретации обычно касается этого тумана; она почти никогда не превращает его во что-то, что похоже на нарисованную от руки схему проводки.

Разреженность цепи меняет цель. OpenAI не утверждает, что достигла прорыва производительности по сравнению с плотной моделью GPT-2; они явно жертвуют эффективностью ради читаемости и доверия. Команда обеспечивает разреженность весов во время самой оптимизации, зануляя все, кроме самых сильных связей, после каждого шага AdamW, и добавляет легкую разреженность активации, так что лишь примерно 1 из 4 внутренних сигналов работает одновременно.

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

Плотные трансформеры размазывают каждое поведение по разветвленным, перекрывающимся подсетям, которые трудно объяснить. Одна единственная особенность может находиться в десятках голов и слоев, переплетаясь с нерелевантными паттернами. Когда исследователи аблатируют части этих моделей, они в основном узнают, что "многое имело значение", а не как работал алгоритм.

Редкие аналоги выглядят почти устаревшими. Для задачи закрытия кавычек OpenAI сообщает о финальной цепи, состоящей всего из 12 внутренних узлов и 9 оставшихся связей, включая один узел, который срабатывает на любые кавычки, и другой, который отслеживает одинарные и двойные кавычки. Та же точность, для достижения которой раньше требовался туман активаций, теперь помещается в нечто более похожее на логическую схему, которую можно распечатать, аннотировать и обсуждать.

Циркуитная разреженность начинается с простого, но жестокого правила: почти каждое соединение должно исчезнуть, пока Sprachmodell все еще учится. OpenAI обучает трансформер в стиле GPT-2 на Python-коде и после каждого обновления AdamW обнуляет все, кроме весов с наибольшей величиной. Никакой мягкой регуляризации, никаких мягких штрафов — соединения либо достаточно важны, чтобы выжить на шаге, либо уходят точно в ноль.

В наиболее агрессивной конфигурации лишь около 1 из 1000 весов остается ненулевым. Это означает, что более 99,9% внутренней проводки исчезает и никогда не вносит тихий вклад за кулисами. Более того, система обеспечивает разреженность активации: в любой момент только около 1 из 4 внутренних сигналов может быть активным.

Эти сигналы охватывают всю структуру трансформера. Бюджет разреженности включает: - Индивидуальные нейроны в блоках MLP - Внимательные головы и каналы - Слоты чтения/записи в остаточном потоке и памяти

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

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

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

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

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

Вместо обрезки после обучения система обнуляет все веса, кроме самых высокомагнитных, после каждого обновления. На ранних этапах тысячи соединений могут передавать сигнал; позже выживает только крошечный бюджет. В конце примерно 1 из 1000 весов остается ненулевым, и лишь около 1 из 4 внутренних активаций может произвести сигнал в любой момент.

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

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

OpenAI затем сравнивает этих разреженных выживших с обычными плотными базовыми моделями при одинаковой потере на задаче. Для простых задач с кодом на Python — закрытие кавычек, подсчет скобок, определение множеств против строк — разреженные модели достигают той же точности, работая на внутреннем оборудовании, которое в среднем примерно в 16 раз меньше. То же поведение, одна шестнадцатая проводки.

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

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

Забудьте неопределенные «особенности» или поэтические разговоры о возникновении поведения. OpenAI все сводит к схемам: крошечным подграфам внутри языковой модели, состоящим из конкретных нейронов, головок внимания и слотов для чтения/записи памяти, плюс индивидуальные веса, которые соединяют их. Каждое выжившее ребро — это единственный ненулевой параметр в море, где более 99.9% весов зафиксированы точно на нуле.

Чтобы увидеть, что на самом деле делают эти цепи, команда сводит пространство задачи к нулю. Они обучаются на 20 маленьких, детерминированных программных головоломках, где модели необходимо выбрать между ровно двумя следующими токенами. Никакой креативности, никакой открытой генерации — просто «А или Б» в строгих рамках.

Многие задачи звучат почти скучно, пока вы не осознаете, что они раскрывают реальную алгоритмическую структуру. Один цикл решает, закрывать ли строку Python одинарной или двойной кавычкой в зависимости от того, какой кавычкой она была открыта. Другой подсчитывает вложенные списки и выбирает между “]” и “]]” в зависимости от текущей глубины скобок, в то время как третий отслеживает, начинала ли переменная свою жизнь как набор или как строка, чтобы впоследствии выбрать `add` или `+=`.

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

Тем, что остается после этого процесса, является «минимальная схема» для задачи: набор узлов и рёбер, которые одновременно достаточны и необходимы для поведения. Никаких панелей интерпретации, никаких послепроцессорных тепловых карт — просто маска над фактическими весами и активациями, которые Sprachmodell использует в момент вывода.

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

Представьте себе крошечную подпрограмму, живущую внутри нейронной сети: 12 единиц, 9 соединений, одна задача. Подайте этой разреженной языковой модели в стиле GPT‑2 неполную строку на Python, и вы сможете буквально увидеть, как запускается специальная «ближайшая кавычка» цепь, выполняет свой алгоритм и снова отключается.

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

Прямо рядом с ним, второй модуль специализируется еще больше. Ему не важна позиция; ему важен тип. Его внутреннее состояние четко разделяет одиночные (') и двойные (") кавычки, различие в один бит, закодированное в непрерывной активации, но использующееся как булево значение.

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

С этого момента цепочка работает как маленький рукописный алгоритм: Обнаружить → Классифицировать → Скопировать → Вывести. Далее юниты считывают сохранённый сигнал типа цитаты, пока модель проходит через остальную часть строки кода. Когда она достигает точки, в которой строка должна завершиться, другой юнит использует этот запомненный фрагмент, чтобы выбрать правильный завершающий токен.

Критически важно, что OpenAI может отключать этот узел схемы по одному. Уберите детектор цитат, и модель перестанет реагировать на цитаты. Заморозьте блок отслеживания типов на постоянном значении, и она всегда будет завершать одним и тем же предложением, независимо от того, что открыло строку.

Исследователи не делают выводы из тепловых карт или неопределенных атрибуций признаков. Они определяют минимальную разреженную цепь, оптимизируя маски, пока не останется только 12 единиц и 9 рёбер, и проверяют, что только этот подпроцессор все еще решает задачу `single_double_quote`. Всё остальное может находиться на среднем значении, и поведение едва меняется.

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

Память проявляется наиболее четко в обманчиво простой задаче: set_or_string. Модель читает код на Python, где переменная может быть создана как `set()` или как строка, а затем ей нужно выбрать между `x.add(...)` или `x += ...`. Этот выбор имеет смысл только если модель помнит, каким образом `x` началась свою жизнь несколько токенов назад.

Скудный трансформер OpenAI не просто "чувствует" паттерны здесь. Когда код определяет `x = set()`, небольшой специализированный подциркут записывает внутренний маркер в остаточный поток: компактная особенность, которая кодирует "x — это множество, а не строка." Параллельный путь активирует другой маркер, когда модель видит `x = "hello"` или аналогичные инициализации строк.

Этот маркер не остается повсюду одновременно. Поскольку модель работает при крайне низкой плотности — примерно 1 из 1000 весов ненулевой и только около 1 из 4 активаций может срабатывать — лишь небольшое количество узлов могут передавать сигнал этого типа. Конкретные головы внимания учатся отслеживать положение переменной и копировать ее типовой маркер во времени, шаг за шагом, по мере поступления новых токенов в Sprachmodell.

Позже, когда код достигает `x ??? что-то`, другая часть цепи активируется. Небольшая группа считывания запрашивает остаточный поток в этот момент, фактически задавая вопрос: "Какой маркер выжил для x?" Если заданный маркер преобладает, цепь направляет вероятность к `.add(`; если выигрывает строковый маркер, она вместо этого усиливает `+=`. Решение зависит от сохраненного, а затем извлеченного внутреннего состояния.

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

Вот почему OpenAI рассматривает это как истинную умышленную память, а не как рыхлое сопоставление шаблонов. Недавно опубликованная работа OpenAI «Гибкие трансформеры с интерпретируемыми цепями» описывает это как конкретный механизм хранения и извлечения: минимальная, подлежащая анализу цепь, которая запоминает факт и позже обращается к нему, чтобы выбрать правильную строку кода.

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

Мост работает как пара адаптеров. Один энкодер преобразует неряшливое скрытое состояние плотной модели в чистое, низкоразмерное пространство разреженной схемы; декодер преобразует любое изменение в этом разреженном пространстве обратно в родной язык плотной модели — язык миллионов активаций.

Этот слой перевода важен, потому что превращает интерпретируемость в двусторонний процесс. Исследователи могут найти функцию в разреженной модели — скажем, цепь set_or_string, которая отслеживает, является ли переменная множеством или строкой — а затем использовать мост, чтобы найти её аналог в модели GPT-2 промышленного масштаба, обученной на тех же данных Python.

Как только они зафиксируют совпадающую характеристику, они могут прикоснуться к ней. Переверните разреженный блок "это набор" через мост и посмотрите, начинает ли плотная модель предпочитать `.add(` вместо `+=`. Подвигайте цепь закрытия кавычек и посмотрите, начнет ли большая модель вдруг неправильно закрывать строки, даже несмотря на то, что веса в плотной сети напрямую не изменились.

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

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

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

OpenAI не просто опубликовала статью; она выпустила рабочий набор лабораторных инструментов. На Hugging Face размещён openai/circuit-sparsity, языковая модель в стиле GPT-2 с 0,4 миллиарда параметров, обученная на коде Python, при этом более 99,9% её весов установлены в ноль. Наряду с этим, полный набор инструментов circuit_sparsity доступен на GitHub, превращая абстрактный результат интерпретируемости во что-то, что вы можете щупать, исследовать и ломать.

Модель маленькая по стандартам 2025 года, но необычайно прозрачная. Только около 1 из 1000 весов выживают в процессе обучения, и только ~1 из 4 внутренних активаций может быть активирована одновременно в различных нейронах, каналах внимания и вспомогательных ячейках чтения/записи. Эта принудительная минималистичность создает разреженные цепи, которые при том же предобучающем уровне потерь работают примерно в 16 раз меньше, чем эквивалентная логика в плотной модели.

Репозиторий GitHub не просто содержит контрольные точки моделей и файл README. Он включает в себя тщательно подобранный набор из около 20 механистических задач, которые подвергают стресс-тестированию внутренние алгоритмы модели, от `single_double_quote` и `bracket_counting` до ресурсоёмкой задачи `set_or_string`. Каждая задача ограничивает модель выбором следующего токена в бинарном формате A/B, что наглядно демонстрирует, когда цепь не срабатывает.

Исследователи также получают встроенные инструменты для обрезки и поиска цепей. Этот набор инструментов может: - Замораживать несущественные узлы на уровне их средних активаций - Маскировать связи до тех пор, пока производительность не ухудшится - Оптимизировать для минимального подграфа, который все еще достигает заданной точности

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

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

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

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

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

Давление на OpenAI продолжает расти со всех сторон. Стартапы и компании-гиганты стремятся обойти API класса GPT, антимонопольные регуляторы исследуют доминирование, а иски по авторским правам и клевете накапливаются вокруг того, как модели обучаются и реагируют. Тем временем, OpenAI тратит колоссальные суммы на графические процессоры, дата-центры и специализированные сети только для того, чтобы поддерживать свои Sprachmodell API в онлайн-режиме.

Этот набор рисков меняет то, что должно означать «современный уровень». Увеличение точности на 0,2% по кодировочному стандарту не помогает, когда регуляторы спрашивают, почему не удалось принять решение по модерации или почему финансовая модель неверно оценила риск. То, что нужно OpenAI — и на что указывает разреженность цепей, — это контролируемый интеллект, а не просто больший интеллект.

Readable AI оказывается в центре внимания надвигающегося регулирования. Законодатели в ЕС, США и Великобритании продолжают выдвигать требования к "объяснимости", аудиторским следам и оценке рисков на уровне системы для моделей с высоким воздействием. Минимальные схемы предоставляют аудиторам и внутренним красным командам объект для инспекции: конкретный подс граф, который реализует "закрыть кавычки" или "отслеживать, является ли эта переменная множеством или строкой".

Вот почему выпуск open-source важен. Модель Hugging Face и репозиторий openai/circuit_sparsity – Открытый выпуск инструментов разреженных цепей превращают интерпретируемость из обещания на слайде в нечто, с чем регуляторы, исследователи и конкуренты действительно могут взаимодействовать. Если OpenAI хочет продолжать функционировать как критическая инфраструктура, такая прозрачная механика может оказаться более важной, чем следующие триллион параметров.

Читаемая ИИ перестает быть метафорой, как только вы можете указать на цепь с 12 узлами и 9 ребрами и сказать: вот где находится решение о закрытии цитаты. Разреженность цепи берет эту идею и превращает ее в инженерную цель: будущие модели должны не только функционировать, но и раскрывать свою внутреннюю логику в виде инспектируемых компонентов. Это переносит интерпретируемость из посмертной экспертизы в проектное ограничение.

Предстоящие функции, такие как запланированный “взрослый режим” ChatGPT, делают этот сдвиг неизбежным. Система, которая тихо определяет, являетесь ли вы ребенком, подростком или взрослым, не может скрыть этот вывод в необнаружимой активационной смеси. Регуляторы, аудиторы и, вероятно, суды захотят знать, какие сигналы — история просмотров, формулировки, время суток, регион — влияли на те или иные схемы, прежде чем модель разрешит откровенный контент.

Разреженные цепи предлагают шаблон для такого рода подотчетности. Если модель безопасности решает, что "пользователь, скорее всего, младше 16", вы хотите иметь небольшой именованный подграф, который поддерживает это мнение, а не тысячу полурасходящихся признаков, разбросанных по остаточному потоку. С помощью разреженности цепей OpenAI демонстрирует, что для задач на Python эквивалентные по поведению цепи могут работать в ~16 раз меньше, чем их плотные аналоги, сохраняя при этом постоянную потерю.

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

• 1Изучите разреженную схему "честности".
• 2Отобразите это в производственную языковую модель.
• 3Жесткий ограничитель или усиление его влияния на результаты

Масштабирование само по себе не может решить эти проблемы. Модель, в 10 раз больше с 10-кратным количеством связанных признаков, только углубляет черный ящик. Разреженность схем указывает на другую грань: АГИ, чья внутренняя структура достаточно понятна для отладки, регулирования и, если необходимо, отключения.

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

Что такое исследование разреженности цепей в OpenAI?

Это метод, при котором ИИ-модель обучается с удалением более 99,9% внутренних соединений. Это заставляет модель разрабатывать небольшие, понятные «схемы» для своей логики, что делает ее процесс принятия решений прозрачным.

Как это отличается от обычной модели ИИ?

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

Почему так важно сделать ИИ понятным?

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

Могу я попробовать это сам?

Да. OpenAI выпустил разреженную модель с 0,4 миллиарда параметров на Hugging Face и полный набор инструментов с визуализацией на GitHub, позволяя исследователям и разработчикам firsthand изучать эти схемы.