Своя модель на своей машине: Llama, Ollama и приватность без облака
Текст написан с позиции сентября 2024 года: так, как тема выглядела тогда, без технологий и событий, появившихся позже.
Пока почти весь разговор про большие языковые модели в 2024 году идет вокруг облачных API — GPT-4o, Claude 3.5 Sonnet, ежемесячные подписки и счета по токенам — тихо и без особого шума вызрела другая ветка. Это открытые модели уровня Llama 3.1, которые можно скачать к себе на машину и запустить локально через Ollama, без интернета и без отправки своего кода чужому серверу. Тема звучит модно, но именно поэтому ее легко подать неправильно. Так что давайте сразу зафиксируем угол: я хочу разобрать локальный inference с инженерной, а не идеологической стороны.
Самая вредная реакция на эту тему — услышать «можно запустить модель локально» и решить, что облако теперь не нужно, а на ноутбуке у тебя живет личный GPT-4. Это не так. Открытые модели на потребительском железе в большинстве задач ощутимо слабее топовых облачных, отвечают медленнее и требуют возни с настройкой. Если ждать от них паритета с фронтиром, разочарование наступит в первый же вечер.
Но есть и обратная крайность, в которую тоже не стоит сваливаться: объявить локальные модели игрушкой для энтузиастов и закрыть тему. Это тоже неправда. У локального inference есть свой совершенно реальный класс задач, где он не просто уместен, а объективно лучше облака. Просто ценность тут другая, и важно не перепутать, в чем именно она состоит.
Если сформулировать главную мысль через привычное противопоставление: ценность локальной модели не в том, что она «не хуже GPT-4» — она хуже, — а в том, что данные не покидают машину, а стоимость владения предсказуема. Это не про качество ответа, а про контроль над данными и над расходами. Дальше я попробую приземлить это до конкретики.
Скачать модель на ноутбук перестало быть подвигом
Чтобы разговор был честным, начнем с того, что реально доступно прямо сейчас. В апреле 2024 года вышла Llama 3, в июле — Llama 3.1, и это заметный сдвиг по сравнению с тем, что было год назад. У Llama 3.1 есть варианты на 8B, 70B и совсем большой 405B параметров, заявленное окно контекста доходит до 128k токенов. Рядом живет линейка Mistral и Mixtral с их mixture-of-experts подходом. Все это — модели с открытыми весами, которые можно скачать и крутить у себя.
Запускать их вручную через llama.cpp можно было и раньше, но именно Ollamaсделала этот процесс по-настоящему человеческим. По сути это локальный runner и небольшой сервер: ставишь его, пишешь ollama run llama3.1, и модель скачивается в уже квантованном виде и стартует. Появляется локальный HTTP-эндпоинт, к которому можно ходить из своего кода почти так же, как ходил бы к облачному API. Магии тут нет — под капотом тот же llama.cpp и привычная квантизация весов, — но developer workflow стал на порядок проще.
Ключевое слово здесь — квантизация. На обычной машине ты почти никогда не запускаешь модель в полной точности. Веса ужимаются до 4-битного или похожего представления, чтобы влезть в доступную память. И вот тут важно понимать честно: 8B-модель в 4-битной квантизации, которая бодро бегает на ноутбуке, и та же архитектура в облаке без агрессивного сжатия — это не одно и то же по качеству. Ты платишь точностью за то, чтобы оно вообще поместилось.
Почему локальная модель — это про данные, а не про скорость
Главный и часто единственный честный аргумент за локальный inference звучит так: данные не уходят с машины. Когда ты отправляешь фрагмент кода в облачный API, ты доверяешь его внешнему сервису — его политикам хранения, его инфраструктуре, его юрисдикции. Для значительной части коммерческого кода и тем более для регулируемых отраслей это само по себе блокер, независимо от того, насколько хороша модель на другом конце провода.
Локальная модель снимает этот вопрос радикально. Можно физически отключить сетевой интерфейс, иOllama продолжит работать: запрос уходит в локальный процесс, ответ возвращается из него же. Нет внешнего сервера — нет утечки, нет логов на чужой стороне, нет вопроса «а что они делают с моими промптами». Это не маркетинговая приватность с галочкой в настройках, а архитектурная: канал наружу просто отсутствует.
Здесь и проходит водораздел. Если ты работаешь с публичным или учебным кодом, аргумент приватности почти ничего не весит — данные и так не секретны. Но если речь про проприетарную кодовую базу, про внутренние документы, про что-то под NDA или про персональные данные, то «модель послабее, но локально» нередко оказывается единственным разрешенным вариантом. Не потому, что она лучше отвечает, а потому, что других вариантов комплаенс просто не оставляет.
Счетчик токенов не тикает, но видеокарта уже оплачена
Второй реальный аргумент — экономика, но не в том смысле, в каком про нее думают на первый взгляд. Облачный API дешев на старте и почти бесплатен, пока ты экспериментируешь в одиночку. Расходы начинают кусаться, когда нагрузка становится постоянной: фоновые задачи, обработка больших объемов текста, эксперименты с длинными промптами, автоматические прогоны по всей кодовой базе. Per-token биллинг устроен так, что счет растет вместе с использованием, и его трудно зафиксировать заранее.
Локальная модель переворачивает эту структуру затрат. Ты один раз платишь за железо (или используешь уже имеющееся), а дальше стоимость каждого следующего запроса — это электричество и твое время. Нет счетчика, который тикает на каждый токен. Для сценариев с высокой и постоянной нагрузкой, где объем запросов большой и предсказуемый, это превращается в понятный capital expense вместо плывущего operating expense.
Но именно здесь нужно быть честным до конца, иначе аргумент превращается в самообман. Покупка или апгрейд машины ради приличной локальной модели — это вполне ощутимые деньги вперед. Видеокарта с достаточным объемом памяти стоит дорого, и чтобы она окупилась против облака, нужен действительно серьезный и регулярный объем работы. Для разработчика, который дергает ассистента десяток раз в день, облако почти наверняка дешевле по совокупной стоимости — никакое локальное железо тут не окупится.
В самолете и в режиме «гоняй сколько хочешь» локалка незаменима
Есть еще два сценария, которые редко попадают в заголовки, но на практике оказываются весомыми. Первый — оффлайн. Самолет, поезд, площадка без нормального интернета, изолированный контур без выхода в сеть по требованиям безопасности. Облачная модель в таких условиях просто недоступна, а локальная продолжает работать ровно так же, как и всегда. Для кого-то это редкий кейс, а для кого-то — постоянное условие работы.
Второй сценарий — эксперименты и обучение. Когда модель живет на твоей машине, исчезает психологический налог на каждый запрос. Можно гонять сотни промптов подряд, перебирать параметры, смотреть, как меняется поведение от температуры и системного промпта, строить свои пайплайны, не глядя на счетчик. Это другой режим работы: ты не «расходуешь бюджет», а свободно играешь с инструментом. Для того, чтобы по-настоящему понять, как ведут себя языковые модели, такой режим бесценен.
Важно при этом не путать понимание механики с пониманием фронтира. Возясь с локальной 8B-моделью, ты отлично прокачиваешь интуицию про токены, контекст, промптинг и квантизацию. Но не стоит по этой интуиции судить о потолке возможностей лучших облачных моделей — это разные весовые категории. Учишь общие принципы локально, оцениваешь потолок по облаку.
Потребительское железо оставляет тебе только самые слабые модели
Теперь самая неудобная часть, без которой разговор был бы нечестным. На обычном ноутбуке или домашнем десктопе ты реалистично запускаешь модели на 7-8B параметров, иногда дотягиваешь до 13B при достаточной памяти. Большие 70B уже требуют серьезной видеокарты или нескольких, а 405B на потребительском железе — это просто не вариант. И вот ровно те модели, которые помещаются легко, — самые слабые в линейке.
Это значит, что сравнивать локальную 8B с GPT-4o или Claude 3.5 Sonnet — заведомо проигрышная для локалки затея. На сложных рассуждениях, на длинном контексте, на аккуратном следовании инструкциям, на редких языках и узких доменах разрыв виден сразу. Маленькая локальная модель чаще ошибается, легче теряет нить в длинном диалоге и хуже держит формат. Это не дефект конкретной сборки, а объективное следствие размера и квантизации.
Добавьте к этому скорость. На машине без мощной видеокарты генерация идет заметно медленнее, чем привычный отклик облачного API. Несколько токенов в секунду на CPU — это та реальность, при которой интерактивная работа становится утомительной. И добавьте возню: подбор квантизации, объем памяти, драйверы, переключение моделей, выбор runner. Все это — startup tax, который ты платишь временем еще до того, как получишь первый полезный ответ.
Поэтому фраза «я поставлю локальную модель и заменю ею облако в работе» для большинства команд — именно самообман. Не потому, что технология плохая, а потому, что совокупная цена — качество плюс скорость плюс возня с железом — для типичной разработки выходит выше, чем понятная подписка на облачный сервис.
Окно в 128k выглядит красиво прежде всего в релиз-нотах
Отдельно стоит остановиться на цифре, которая чаще всего цепляет в анонсах: окно контекста до 128k токенов у Llama 3.1. На бумаге это означает, что можно скормить модели огромный кусок кодовой базы или большой документ целиком. И технически это правда — поддержка такого окна заявлена. Но между «модель принимает 128k» и «модель полезно работает на 128k локально» лежит большая дистанция, которую важно не проскочить.
Первая проблема — память. Длинный контекст — это не только сами веса, но и растущий KV-кэш, который нужно где-то держать. Чем больше токенов ты держишь в окне, тем больше памяти под это уходит, и на потребительском железе ты упираешься в потолок задолго до заявленного максимума. Реальная длина, с которой ты комфортно работаешь локально, обычно в разы скромнее красивой цифры из релиз-нот.
Вторая проблема — не в объявленном лимите, а в качестве внимания на длинном контексте. Маленькая квантованная модель тем хуже удерживает связи между далеко разнесенными фрагментами, чем длиннее окно. Формально текст в контексте есть, фактически модель про середину может почти забыть. Поэтому 128k у локальной 8B и 128k у топовой облачной модели — это снова не одна и та же возможность, а одинаково звучащие числа с очень разной отдачей.
Спрашивай не «что круче», а «что здесь ограничение»
Самый трезвый способ принять решение — не спрашивать «что круче», а спрашивать «что в этой задаче является ограничением». Если ограничение — приватность данных или требование изоляции контура, выбор почти предопределен в пользу локального inference, даже ценой качества. Если ограничение — качество ответа на сложной задаче, локалка отпадает, и нужно облако. Это не вопрос вкуса, а вопрос того, какой фактор для конкретной работы критичен.
Полезно держать в голове короткий список честных вопросов:
- Уходят ли данные с машины — и можно ли это вообще себе позволить в этой задаче?
- Какой объем запросов: разовый и небольшой или постоянный и большой?
- Нужна ли интерактивная скорость отклика или работа фоновая и терпит задержку?
- Хватает ли качества модели на 8-13B для этой конкретной задачи, или нужен фронтир?
- Есть ли уже подходящее железо, или его придется покупать только ради этого?
Ответы на эти вопросы почти всегда разводят сценарии по полочкам без всякой идеологии. Приватный разбор внутренней кодовой базы в изолированном контуре — это Ollama и Llama 3.1 локально, и тут компромисс по качеству оправдан. Интерактивная помощь по сложной архитектурной задаче на публичном коде — это облако, и спорить тут не о чем. Большая часть реальных команд будет жить в гибридном режиме: что-то держать локально из-за данных, а за качеством ходить в облако.
Не победа над облаком, а еще одна дверь
Появление зрелого локального стека — это не революция и не конец облака, а расширение пространства выбора. Раньше у инженера фактически был один путь: чужой сервер и биллинг по токенам. Теперь рядом появилась осязаемая альтернатива со своими условиями — данные под контролем, расходы фиксированы, но качество и удобство ниже. Это сдвиг, а не победа, и относиться к нему стоит соответственно.
Мне нравится, что локальные модели возвращают в разговор тему ownership. Когда модель живет на твоей машине, ты лучше понимаешь, что вообще происходит: где данные, сколько это стоит, от чего зависит качество. Это полезная инженерная гигиена даже для тех, кто в итоге останется на облаке. Понимание границ инструмента важнее, чем привычка к одному провайдеру.
Если же приземлить главный практический вывод совсем прямо: локальная модель через Ollama стоит того не там, где она якобы заменяет GPT-4, а там, где данные не должны покидать машину или где per-token биллинг неприемлем; за эту приватность и предсказуемость ты платишь качеством, скоростью и возней с железом — и для большинства команд в сентябре 2024 года облако по совокупной цене все еще выгоднее. Не «локальное против облачного» как война лагерей, а трезвый выбор инструмента под конкретное ограничение задачи.