Я запустил локальную нейросеть на Raspberry Pi 12-летней давности (И она реально заработала!)

Русскийالعربية Deutsch English Español Français हिन्दी Bahasa Indonesia 日本語 한국어 Português 中文

Computing/SoftwareConsumer Electronics

Transcript

00:00:00Это Raspberry Pi первого поколения, которая вышла еще в 2014 году.

00:00:05У нее одноядерный процессор с частотой 700 МГц и 512 МБ оперативной памяти.

00:00:12По современным меркам это, по сути, калькулятор.

00:00:16Но сегодня мы проверим, сможем ли мы выжать максимум из этого 12-летнего железа,

00:00:21запустив на нем большую языковую модель локально.

00:00:26В этом видео я покажу крошечную модель, которую можно запустить на Raspberry Pi,

00:00:30мы оценим ее работу, и я покажу, как установить все необходимые зависимости,

00:00:35чтобы вы могли попробовать это сами.

00:00:37Будет очень интересно, так что поехали.

00:00:40Честно говоря, я не думал, что удастся найти модель,

00:00:47достаточно легкую для такой архитектуры.

00:00:49Но после поисков я все же нашел кандидата.

00:00:52Встречайте — Falcon H1 Tiny.

00:00:54Это невероятно компактная модель, в которой всего 90 миллионов параметров.

00:00:59Она была разработана Технологическим инновационным институтом в Абу-Даби

00:01:03специально для исследования экстремально низких порогов языкового моделирования.

00:01:08Но как им удалось сделать модель такой маленькой?

00:01:10Есть ли в этом какой-то секретный технический ингредиент?

00:01:13Ну, не совсем.

00:01:14Они используют ту же гибридную архитектуру Transformer + Mamba,

00:01:19которую такие компании, как IBM, использовали для своих крошечных моделей Granite 4.

00:01:24Об этом я тоже снимал видео, можете посмотреть.

00:01:27Но вот в чем дело.

00:01:28Чтобы успешно уместить эту модель в памяти, нам нужно поговорить о квантовании.

00:01:33Модели Falcon доступны в 2-битной, 4-битной и 8-битной версиях.

00:01:38У вас может возникнуть соблазн попробовать сверхлегкое IQ или «важное» квантование.

00:01:43Но здесь есть подвох.

00:01:45Эти новые методы полагаются на сложные битовые манипуляции,

00:01:49требующие современных инструкций процессора для эффективности.

00:01:52На нашем старом чипе ARMv6 в Raspberry Pi это не сработает.

00:01:57Поэтому нам придется выбрать олдскульные модели Q4 —

00:02:01золотой стандарт для нашего случая.

00:02:04Там используется классический метод квантования среднего размера,

00:02:07с которым процессор Pi справится без перегрузки.

00:02:11Это дает оптимальное соотношение интеллекта на мегабайт, сохраняя логику.

00:02:17Но запустить эту модель на первом Raspberry Pi — задача не из простых.

00:02:22Так как Pi использует архитектуру ARMv6,

00:02:26в ней нет современных инструкций NEON, от которых зависят почти все ИИ-библиотеки.

00:02:31К счастью, есть llama.cpp, которую мы можем использовать для инференса.

00:02:36Но для этого нужно скомпилировать бинарный файл именно под наш ARMv6.

00:02:42Если вы попытаетесь скомпилировать его прямо на Pi,

00:02:45это займет часов 18, пока компилятор закончит работу.

00:02:49И это если он раньше не вылетит из-за нехватки памяти.

00:02:53Так что нам придется проявить немного изобретательности.

00:02:56Нам нужно выполнить кросс-компиляцию этих файлов на ноутбуке через dockcross,

00:03:02целясь в набор инструкций ARMv6 с включенным модулем VFP math,

00:03:08а затем перенести их по SSH, чтобы сразу приступить к делу.

00:03:13Именно это мы сейчас и сделаем.

00:03:15Сначала прошьем самую легкую ОС на нашу Pi через Raspberry Pi Imager.

00:03:22Для платы с 512 МБ оперативной памяти важен каждый мегабайт.

00:03:28Я выберу Raspberry Pi OS Lite, 32-битную версию,

00:03:32так как в ней нет рабочего стола и она потребляет лишь малую часть памяти

00:03:38по сравнению со стандартной ОС, оставляя почти всё ОЗУ для запуска модели.

00:03:44И еще один важный момент: в расширенных настройках

00:03:47настройте Wi-Fi и включите SSH заранее.

00:03:51На старых платах гораздо удобнее управлять всем удаленно,

00:03:55чтобы не мучиться с тормозящим локальным терминалом.

00:03:58Когда Pi загрузится и мы подключимся по SSH, пора решать проблему с ARMv6.

00:04:05Если бы мы начали компилировать llama CPP прямо здесь,

00:04:08Pi буквально провела бы следующие полтора дня, переваривая заголовки.

00:04:13Поэтому мы сделаем это на обычном ноутбуке, чтобы ускорить процесс и сэкономить время.

00:04:18Клонируем исходный код llama CPP и создадим отдельную директорию

00:04:23для сборки, которую мы будем использовать на Raspberry Pi.

00:04:28Но вот еще одна проблема.

00:04:29У моего Mac архитектура ARMv8 (64 бита), а не 32-битная ARMv6.

00:04:37И у них разные наборы инструкций.

00:04:40Чтобы собрать бинарник для Pi, нам нужен dockcross —

00:04:45это инструментарий кросс-компиляции, который работает на Mac,

00:04:48но создает файлы специально для старой архитектуры Pi.

00:04:53Затем нужно сконфигурировать сборку.

00:04:55Здесь нужно быть предельно точными.

00:04:58Нам нужно передать несколько специфических флагов.

00:05:00Во-первых, отключим общие библиотеки, чтобы создать один переносимый файл.

00:05:05Затем выключим NEON, так как в нашей Pi нет этих математических инструкций.

00:05:10И отключим OpenMP, чтобы максимально снизить потребление памяти.

00:05:15Мы, по сути, убираем все современные излишества,

00:05:18чтобы бинарный файл был совместим со старой платой Pi.

00:05:22Теперь запускаем сборку, и через пару минут у нас будет готовый,

00:05:26оптимизированный бинарник llama-completion для нашей Pi.

00:05:31Теперь через SSH подключаемся к плате по сети,

00:05:35создаем новую папку и через SCP копируем туда наш скомпилированный файл.

00:05:42И последнее действие.

00:05:44Давайте скачаем 2-битную, 4-битную и 8-битную квантованные модели Falcon,

00:05:50потому что мы будем тестировать их по очереди.

00:05:53И скопируем их на Pi одну за другой в папку models.

00:05:58А теперь — самое интересное.

00:05:59Переходим в терминал Pi и запускаем первый тест инференса.

00:06:03Начнем с самого агрессивного сжатия — 2-битной модели.

00:06:07Нам нужно выполнить вот эту длинную команду.

00:06:10По сути, я отправляю простой запрос

00:06:13«Привет, как дела?» и ограничиваю ответ 32 токенами.

00:06:18Мы указываем ровно один поток, так как больше у нас просто нет.

00:06:22И ставим крошечный размер контекста — 128 токенов, чтобы беречь каждый байт памяти.

00:06:29Но самый важный флаг здесь — «no mmap».

00:06:32Обычно llama CPP использует отображение памяти для загрузки моделей, что круто для мощных GPU,

00:06:38но для нашей Pi это кошмар.

00:06:41В 32-битной системе всего с 512 мегабайтами

00:06:45mmap может вылететь, если не найдет непрерывный блок адресного пространства.

00:06:50Отключив его, мы заставляем модель грузиться напрямую в «кучу» (heap),

00:06:55что дает более стабильный контроль над нашей ограниченной памятью.

00:06:58Ну что, запускаем.

00:07:00И вот они — наши первые токены.

00:07:03Как видим, 2-битная версия сильно буксует.

00:07:08Во-первых, один токен обрабатывается примерно раз в три секунды,

00:07:14что ожидаемо для старой Raspberry Pi.

00:07:18Но главное — ответ получается абсолютно бессмысленным.

00:07:21В модели на 90 млн параметров веса сжаты настолько,

00:07:25что лингвистическая логика просто рассыпалась.

00:07:28Она едва связна, но технически — всё работает.

00:07:32Посмотрим, что будет, если переключиться на 4-битную модель.

00:07:35И гляньте — теперь мы получили внятное приветствие!

00:07:40Это успех.

00:07:42На Pi локально запущена настоящая ИИ-модель,

00:07:47которая логично отвечает на наши запросы.

00:07:49Ура!

00:07:50Теперь пойдем еще дальше.

00:07:53Потянет ли Pi 8-битную модель?

00:07:56На этот раз я спрошу что-то посложнее,

00:07:59например, «Какая столица у Албании?»

00:08:02И... ответ неверный, так как столица Албании — Тирана,

00:08:08и это явно фактическая ошибка.

00:08:10Но если я спрошу про столицу Бельгии, она отвечает правильно.

00:08:15Это показывает кое-что интересное.

00:08:17У такого сильного сжатия до 90 млн параметров есть своя цена.

00:08:22Она может знать факты о больших, популярных странах,

00:08:26но «плавать» в менее известных странах и темах.

00:08:31Такова природа знаний.

00:08:33В 90 миллионов параметров можно уместить лишь ограниченный объем данных.

00:08:38Но тем не менее, результат очень крутой.

00:08:41Мы подтвердили: да, существуют ИИ-модели,

00:08:46достаточно легкие для запуска на 12-летней Raspberry Pi.

00:08:50Быстро ли это?

00:08:51Черта с два.

00:08:52Точно ли это?

00:08:53Далеко не всегда.

00:08:54Стоит ли использовать это в продакшене?

00:08:55Скорее нет.

00:08:57Если только вы не строите ну о-о-очень медленного робота.

00:09:02Но главное — теперь мы знаем, что это теоретически возможно.

00:09:06В общем-то, это всё, что я хотел доказать в этом видео.

00:09:09Честно говоря, эксперимент получился очень фановым.

00:09:13Вот такие дела, друзья.

00:09:14Это были модели Falcon H1 Tiny.

00:09:17Вероятно, самые маленькие ИИ-модели на данный момент.

00:09:20И теперь мы знаем, что они реально могут работать на первой Raspberry Pi,

00:09:25и это суперкруто.

00:09:27Не перестаю радоваться этому факту.

00:09:30Хоть практической пользы в этом ноль, всё равно круто.

00:09:35Пишите в комментариях, что вы думаете

00:09:37об увиденном.

00:09:40Жду ваших мнений внизу под видео.

00:09:42И если вам нравятся такие технические разборы,

00:09:45поддержите нас лайком.

00:09:49А также не забудьте подписаться на наш канал.

00:09:51С вами был Андрис из Better Stack, увидимся в следующих видео!

Key Takeaway

Локальный запуск большой языковой модели возможен даже на микрокомпьютере Raspberry Pi 12-летней давности с 512 МБ ОЗУ при условии кросс-компиляции бинарного файла под архитектуру ARMv6 без инструкций NEON и использовании 4-битной модели Falcon H1 Tiny на 90 миллионов параметров.

Highlights

Микрокомпьютер Raspberry Pi первого поколения имеет одноядерный процессор с частотой 700 МГц и всего 512 МБ оперативной памяти.
Языковая модель Falcon H1 Tiny содержит всего 90 миллионов параметров и использует гибридную архитектуру Transformer + Mamba.
Старый чип ARMv6 не поддерживает современные инструкции NEON и сложные методы квантования вроде IQ, что требует использования классического метода Q4.
Сборка инференса llama.cpp непосредственно на плате Raspberry Pi занимает около 18 часов и может прерваться из-за нехватки памяти.
Отключение отображения памяти с помощью флага no mmap заставляет модель загружаться напрямую в кучу (heap), предотвращая сбои в 32-битной системе.
4-битная версия Falcon H1 Tiny успешно генерирует осмысленные ответы, тогда как веса 2-битной версии пережаты до потери лингвистической логики.

Timeline

Технические характеристики аппаратного обеспечения и выбор нейросети

Аппаратной платформой для эксперимента выступает оригинальная плата Raspberry Pi 2014 года выпуска.
Для тестирования выбрана сверхкомпактная языковая модель Falcon H1 Tiny на 90 миллионов параметров.

Устройство оснащено одноядерным процессором, работающим на частоте 700 МГц, и располагает 512 МБ оперативной памяти. Из-за жестких ограничений по объему памяти стандартные модели не подходят. Выбранная нейросеть создана в Технологическом инновационном институте в Абу-Даби для исследования низких порогов моделирования. В ее основе лежит гибридная архитектура Transformer + Mamba, аналогичная решениям в линейке IBM Granite 4.

Ограничения архитектуры ARMv6 и выбор метода квантования

Современные методы квантования несовместимы со старым процессором из-за отсутствия необходимых инструкций.
Оптимальным решением для старого чипа является классический метод квантования Q4 среднего размера.

Новые методы вроде важного квантования (IQ) полагаются на сложные битовые манипуляции. Процессор ARMv6 на плате Raspberry Pi не поддерживает такие вычисления на аппаратном уровне. Использование классического метода Q4 позволяет избежать перегрузки процессора. Данный подход обеспечивает наилучшее соотношение вычислительной логики и объема занимаемой памяти.

Стратегия оптимизации операционной системы и кросс-компиляция

Компиляция инференса llama.cpp на самом микрокомпьютере нецелесообразна из-за временных затрат.
Для экономии оперативной памяти требуется установка минимальной версии операционной системы без графического интерфейса.

Процесс сборки кода на слабом процессоре занимает около 18 часов с высоким риском аварийного завершения. Проблема решается путем кросс-компиляции на ноутбуке с использованием инструментария dockcross. В качестве ОС выбирается 32-битная Raspberry Pi OS Lite. Отсутствие графической оболочки сохраняет максимальный объем ОЗУ для нужд нейросети, а управление платой осуществляется удаленно через SSH.

Конфигурация сборки и перенос файлов на устройство

Сборка бинарного файла под архитектуру ARMv6 требует принудительного отключения современных инструкций.
Готовый исполняемый файл и три варианта квантованных моделей переносятся на плату по локальной сети.

При конфигурировании сборки отключаются общие библиотеки для создания одного переносимого файла. Флаг NEON деактивируется из-за отсутствия соответствующих математических инструкций в процессоре платы. Для минимизации потребления памяти также отключается поддержка OpenMP. После завершения компиляции оптимизированный файл llama-completion и модели с разной битностью (2-bit, 4-bit, 8-bit) копируются на устройство через SCP.

Результаты тестирования инференса нейросети на Raspberry Pi

Запуск инференса требует отключения отображения памяти во избежание сбоев в 32-битной системе.
4-битная модель демонстрирует оптимальный баланс между скоростью работы и связностью текста.

Флаг no mmap заставляет модель загружаться напрямую в кучу (heap), что предотвращает падение системы при отсутствии непрерывных блоков адресного пространства в 512 МБ ОЗУ. Тест выполняется в один поток с контекстом в 128 токенов. 2-битная модель выдает бессмысленный набор слов со скоростью один токен в три секунды. 4-битная версия успешно справляется с простыми диалогами. 8-битная модель работает точнее, но имеет ограничения по объему встроенных фактов из-за малого размера в 90 миллионов параметров.

Community Posts

No posts yet. Be the first to write about this video!

Write about this video