Использование Maс3 для запуска LLM локально.

19.05.2025 13:03

Это перевод статьи https://medium.com/@lukekerbs/goodbye-api-keys-hello-local-llms-how-i-cut-costs-by-running-llm-models-on-my-m3-macbook-a3074e24fee5

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

Прощайте, API-ключи, привет, местные LLM: как я сократил расходы, запустив модели LLM на моем MacBook M3

Руководство разработчика по бесплатному ИИ с Python и MLX на Apple Silicon

Было 2 часа ночи во вторник, когда я наконец сорвался. Я пялился на панель управления использованием API OpenAI, наблюдая, как кредиты утекают, как песок в песочных часах, пока я тестировал свой последний проект. Каждый вызов API был похож на бросание монет в цифровой колодец желаний, за исключением того, что желания были просто... обычными разговорами с ИИ.

«Должен быть способ получше», — подумал я. Оказывается, он есть!

После некоторых поисков я обнаружил MLX-LM — фреймворк Apple для локального запуска больших языковых моделей на компьютерах Mac с Apple Silicon. В течение недели я отменил подписку OpenAI и настроил мощное локальное решение LLM, которое работает полностью на моем MacBook. Никаких ключей API, никаких счетчиков использования, никакой сетевой задержки — просто мой компьютер делает то, что должны делать компьютеры: вычисляет всякую всячину.

В этой статье я расскажу вам, как я освободился от облачной парадигмы ИИ и создал собственную локальную языковую модельную площадку с использованием Python и MLX-LM. Внимание, спойлер: это на удивление просто.

Расставание с облаком: почему я решился на этот переход

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

Вот почему я в конце концов решил прекратить это:

Мой кошелек чувствовал боль : Смотри, цены OpenAI не возмутительны для повседневного использования, но когда ты разрабатываешь и тестируешь? Эти пенни очень быстро складываются в доллары. Каждый раз, когда я запускал цикл отладки со 100 итерациями, я практически слышал, как плачет моя кредитная карта.
Проблемы конфиденциальности : Отправка каждого фрагмента текста, с которым я работал, на удаленные серверы стала вызывать дискомфорт, особенно при работе с персональными или клиентскими данными. Это как иметь блестящего научного сотрудника, который также сплетничает о твоей работе всем, кто готов слушать.
Ожидание ответов было похоже на коммутируемый доступ в Интернет: Помните визг модема 56k?Именно так и начинало ощущаться ожидание ответов API — особенно при работе с более длинными контекстами.
Я хотел поковыряться под капотом : когда ваша модель живет на чужом сервере, вы застряли с их параметрами, их ограничениями скорости, их правилами. Я из тех разработчиков, которые любят открывать вещи и смотреть, как они работают.
Иногда интернет просто... не работает : попробуйте отладить свое приложение на базе ИИ, когда ваше интернет-соединение решит уйти в незапланированный отпуск. Не весело.

Встречайте MLX-LM: подарок Apple разработчикам искусственного интеллекта

Так что же такое MLX-LM?

MLX-LM — это библиотека Python, созданная на основе фреймворка MLX от Apple, которая позволяет запускать большие языковые модели непосредственно на вашем Mac с Apple Silicon. Она использует эти модные «нейронные движки» в чипах серии M, чтобы обеспечить удивительно хорошую производительность без необходимости в выделенном графическом процессоре.

Лучшая часть? Он поддерживает множество популярных моделей с открытым исходным кодом, таких как Mistral, Llama, Phi и Gemma. Благодаря умным методам квантования (по сути, сжатию моделей для большей эффективности) вы можете запускать модели с миллиардами параметров даже на машине с ограниченной оперативной памятью.

Начало работы: проще, чем приготовить лапшу быстрого приготовления

Настройка MLX-LM неожиданно проста. Никаких сложных зависимостей, никаких кошмаров совместимости — всего одна команда:

pip установить mlx-lm

Вот и все. Серьезно. Эта единственная команда устанавливает все, что вам нужно для запуска моделей локально. Когда я впервые это обнаружил, я ждал подвоха — наверняка будут проблемы с драйверами или какая-то сложная настройка? Нет. Инженеры Apple заслуживают золотую звезду за этот оптимизированный опыт.

Ваш первый местный LLM: Привет (местный) мир

Начнем с самых основ — загрузки модели и генерации текста:

из импорта mlx_lm загрузить, сгенерировать

# Загрузить 4-битную квантованную модель Mistral 7B , tokenizer = load( "mlx-community/Mistral-7B-Instruct-v0.3-4bit", tokenizer_config={"trust_remote_code": True} )# Генерация текста из подсказки prompt = "Напишите хокку о кодировании в дождливый день." response = generate( model, tokenizer, prompt, max_tokens=256, verbose=True # Показывает статистику генерации, например скорость )печать(ответ)

При первом запуске MLX-LM загрузит модель (около 3,8 ГБ для этой конкретной модели), что может занять несколько минут в зависимости от вашего интернет-соединения. Но после этой первоначальной загрузки? Молниеносный локальный вывод.

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

Создание чат-приложения, не требующего оплаты за сообщение

Большинство практических приложений LLM в наши дни включают чат-взаимодействия. Вот как создать простое чат-приложение с MLX-LM:

из mlx_lm импорт загрузка, генерация из mlx_lm. models . кэш импорт make_prompt_cache

# Загрузить модель (здесь я использую 3-битную Llama 3 — даже меньше!) model, tokenizer = load("mlx-community/Llama-3.1-8B-Instruct-3bit")# Создать кэш для эффективных многооборотных разговоров prompt_cache = make_prompt_cache(model)# Настраиваем историю сообщений чата = []def chat_turn(user_input): # Добавить сообщение пользователя в историю messages.append({"role": "user", "content": user_input}) # Отформатировать беседу, используя шаблон чата модели prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True) # Сгенерировать ответ, используя кэшированные пары ключ-значение для эффективности response = generate( model, tokenizer, prompt, max_tokens=512, temp=0.7, prompt_cache=prompt_cache ) # Добавить ответ помощника в историю messages.append({"role": "assistant", "content": response}) return response# Пример разговора print(chat_turn("Если бы вам пришлось объяснить моему коту, что такое квантовые вычисления, как бы вы это сделали?")) print(chat_turn("Кажется, мой кот запутался в суперпозиции. Можете прояснить?"))

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

Потоковые ответы, такие как ChatGPT

Если вам нужен более интерактивный опыт с постепенным появлением токенов (например, эффект набора текста в ChatGPT), потоковая передача — ваш друг:

из mlx_lm импортировать stream_generate

messages = [{"role": "user", "content": "Напишите короткую историю о программисте, который обнаружил искусственный интеллект, живущий в его холодильнике."}] prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True)# Потоковая передача токена ответа за токеном для ответа в stream_generate(model, tokenizer, prompt, max_tokens=512): print(response.text, end="", flush=True) # Необязательно: отображение скорости генерации (мне нравится видеть статистику) if response.generation_tokens % 20 == 0: # Каждые 20 токенов print(f"\n[Скорость: {response.generation_tps:.1f} токенов/сек]", end="", flush=True)

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

Управление памятью и оптимизация с помощью MLX

Одной из проблем локального запуска этих моделей является управление памятью. Вот как я оптимизирую использование памяти:

из mlx_lm импорт сгенерировать из mlx_lm.models.cache импорт make_prompt_cache импорт mlx.core как mx

# Создать кэш подсказок, эффективно использующий память prompt_cache = make_prompt_cache( model, max_kv_size=4096 # Ограничить размер кэша, чтобы предотвратить раздувание памяти )# Генерация с квантованным кэшем KV для еще большей эффективности памяти response = generate( model, tokenizer, prompt, prompt_cache=prompt_cache, kv_bits=4, # Квантование кэша до 4 бит kv_group_size=64 # Размер группы квантования )# Очистить кэш памяти GPU после больших операций mx.metal.clear_cache()

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

Обучение вашей модели новым трюкам: тонкая настройка модели MLX

Одной из самых крутых функций MLX-LM является возможность тонкой настройки моделей с вашими собственными данными с помощью техники, называемой Low-Rank Adaptation (LoRA). Вот где локальный подход действительно сияет — попробуйте тонкую настройку модели через API и посмотрите, как ваш кошелек лопнет.

Вот как это можно сделать:

# Сначала подготовьте обучающие данные в формате JSONL # Пример формата: # { "messages" : [{ "role" : "user" , "content" : "..." }, { "role" : "assistant" , "content" : "..." }]}

# Затем обучите адаптеры LoRA с помощью файла конфигурации mlx_lm.lora \ --model "mlx-community/Llama-3.1-8B-Instruct-3bit" \ --train \ --data "train.jsonl" \ --val-data "val.jsonl" \ --config "lora_config.yaml" \ --out-dir "my-lora-adapters"

А чтобы использовать вашу персонализированную модель:

# Загрузите модель с вашими адаптерами LoRA , tokenizer = load( "mlx-community/Llama-3.1-8B-Instruct-3bit" , adapter_path= "my-lora-adapters" )

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

Как это на самом деле работает?

Когда дело доходит до производительности, важно понимать компромиссы между локальными моделями и облачными API. Вот что я заметил:

Скорость : Фактическая скорость генерации сильно варьируется в зависимости от модели вашего Mac, размера LLM и ваших настроек. На моей установке я получаю разумную производительность, которая кажется отзывчивой для интерактивного использования, особенно с меньшими квантованными моделями.
Использование памяти : Квантованные модели — настоящие герои здесь. 4-битная квантованная модель параметров 7B может использовать около 8 ГБ ОЗУ, а 3-битная модель — еще меньше. Это делает эти модели осуществимыми на компьютерах Mac с 16 ГБ+ памяти.
Качество : Это наиболее субъективный аспект. Хотя GPT-4 от OpenAI по-прежнему лидирует по общим возможностям, разрыв сокращается. Для многих рутинных задач модели с открытым исходным кодом, такие как Llama 3 и Mistral, работают превосходно.
Отзывчивость : Отсутствие сетевой задержки имеет огромное значение в ощущениях от использования этих моделей. Первый токен появляется практически мгновенно после отправки подсказки, что создает гораздо более отзывчивый опыт по сравнению с вызовами API.

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

Обслуживание клона API OpenAI на вашем Mac с помощью MLX

Хотите пойти до конца и создать собственную локальную альтернативу OpenAI API? MLX-LM включает в себя встроенный HTTP-сервер, который делает это чрезвычайно простым:

mlx_lm.server \ --model "mlx-community/Llama-3.1-8B-Instruct-3bit" \ --chat- template "chatml" \ --port 8000

Это запускает локальный сервер с конечными точками, которые имитируют API OpenAI:

# Клиентский код, использующий запросы импорта запросов

response = requests.post( "http://localhost:8000/v1/chat/completions", json={ "messages": [{"role": "user", "content": "Какой лучший способ изучить Python?"}], "temperature": 0.7, "stream": True }, stream=True )для строки в response.iter_lines(): если строка: print(line.decode('utf-8'))

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

Мудрость, добытая тяжелым трудом: практические советы с передовой

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

Начните с малого, затем масштабируйте : начните с меньших, квантованных моделей, таких как 3-битные или 4-битные варианты. Они быстрее, требуют меньше памяти и на удивление способны выполнять большинство задач. Вы всегда сможете перейти к более крупным моделям позже, если это необходимо.
Поток, поток, поток : всегда используйте API потоковой передачи при создании интерактивных приложений. Это делает все более отзывчивым, даже когда генерация занимает время.
Память — ваш друг (пока это не так) : следите за использованием памяти с помощью Activity Monitor. Периодически очищайте кэш mx.metal.clear_cache()и устанавливайте соответствующие ограничения кэша, особенно для долго работающих приложений.
Температура — это больше, чем просто число : поиграйте с параметрами генерации, такими как температура, top_p и штраф за повторение. Нахождение правильного баланса может значительно улучшить качество вывода. Обычно я использую более низкие температуры (0,3–0,5) для фактических задач и более высокие (0,7–0,8) для творческой работы.
Рассмотрите гибридные подходы : для некоторых приложений я использую локальные модели для разработки и конфиденциальных данных, сохраняя при этом доступ к API в качестве резерва для специализированных задач. Нет правила, которое гласит, что вы должны полностью отдаваться любому подходу.

Реальные приложения: что я создал

После перехода на MLX-LM я создал несколько приложений, реализация которых при использовании моделей на основе API была бы слишком затратной:

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

Быть честным: ограничения и компромиссы

Конечно, ни одно решение не идеально. Вот несколько честных ограничений, с которыми я столкнулся:

Ограничения по размеру модели : даже при квантовании самые большие модели (70B+ параметров) могут быть сложными для запуска на потребительском оборудовании. Я обнаружил, что наилучший вариант находится в диапазоне параметров 7B-13B.
Начальная загрузка : при первом использовании модели вам нужно будет загрузить несколько гигабайт, что может занять несколько минут в зависимости от вашего соединения. Но это справедливо для любой модели с открытым исходным кодом.
Срок службы батареи : Запуск интенсивного вывода разрядит вашу батарею быстрее, чем типичные задачи. Я научился держать зарядное устройство под рукой во время тяжелых рабочих нагрузок LLM.
Передовые возможности : Для некоторых специализированных задач самые передовые фирменные модели (например, GPT-4) все еще сохраняют некоторые преимущества. Разрыв сокращается, но не закрылся полностью.
Требуются технические знания : Настройка и конфигурирование локальных моделей требует больше технических знаний, чем просто вставка ключа API. Требуется обучение.

Сравнение цен: ваш Mac против гонки вооружений на графических процессорах

Давайте немного поговорим о деньгах, поскольку это может быть самой веской причиной попробовать подход MLX-LM.

Запуск моделей на выделенных графических процессорах Nvidia — традиционный способ работы с ИИ, но вы в последнее время оценивали их? Приличный графический процессор для работы с ИИ стоит около 1000 долларов (если вы сможете найти его по рекомендованной розничной цене) и легко поднимается до 3000 долларов и более для моделей высокого класса. И это только стоимость оборудования — добавьте энергопотребление, потребности в охлаждении и системную интеграцию.

Аренда облачных GPU не намного лучше. Один экземпляр A100 GPU может стоить $1,50-$4,00 в час в зависимости от поставщика. Если вы проводите масштабные эксперименты или создаете приложения, эти расходы растут пугающе быстро.

Но вот прекрасная простота подхода MLX-LM: вы используете уже имеющееся у вас оборудование. Мой MacBook Pro на 18 ГБ с чипом M3 не был куплен специально для работы с ИИ — это мой повседневный компьютер. Локальное использование этих моделей означает:

Никаких дополнительных затрат на оборудование
Никаких постоянных арендных платежей
Никаких сложных облачных конфигураций
Никаких затрат на полосу пропускания при отправке данных туда и обратно

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

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

Моя конфигурация: M3 MacBook Pro с 18 ГБ ОЗУ

Я должен упомянуть, что я запускаю все это на моем 18 ГБ MacBook Pro с чипом M3. Это аппаратное сладкое пятно оказалось более чем способным для большинства моих локальных потребностей LLM. Нейронный движок в M3 эффективно обрабатывает матричные операции, необходимые этим моделям, в то время как 18 ГБ ОЗУ дают мне достаточно запаса для запуска даже более крупных 7B и некоторых 13B параметрических моделей (при квантовании).

Когда я впервые решил попробовать локальные LLM, я не был уверен, справится ли мой MacBook с этой задачей. Существует устойчивый миф о том, что для запуска чего-либо, связанного с ИИ, нужно специализированное оборудование с массивными графическими процессорами. Но Apple Silicon кардинально изменила это уравнение. Мой относительно стандартный MacBook Pro справляется с этими моделями с удивительной грацией, лишь изредка раскручивая вентиляторы, когда я выхожу за рамки с более крупными моделями или более длинными последовательностями поколений.

Путь вперед: почему я не оглядываюсь назад

Несмотря на ограничения, упомянутые ранее, я не пожалел о своем решении отказаться от моделей на основе API. Свобода экспериментировать без наблюдения за работой счетчика, преимущества конфиденциальности от хранения данных локально и удивительная производительность Apple Silicon с MLX-LM изменили мой подход к ИИ в моих проектах.

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

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

Ваша очередь: присоединяйтесь к местной революции LLM

Если у вас есть Mac с Apple Silicon, я рекомендую вам попробовать MLX-LM. Свобода экспериментировать без счетчиков использования раскрепощает, а преимущества конфиденциальности существенны. Вы можете удивиться, насколько эффективной может быть ваша локальная настройка.

Готовы начать? Установите MLX-LM сегодня pip install mlx-lmи присоединяйтесь к местной революции LLM!