Open Source LLM — Llama / Qwen / DeepSeek
1.49K subscribers
8 photos
2 videos
24 links
Open Source LLM — про open-source LLM глазами арбитражника:
свой API без OpenAI, локальный inference, файнтюны.
Канал сети public.tg.
Download Telegram
This media is not supported in your browser
VIEW IN TELEGRAM
Как заработать 2500$ с УБТ трафика из Twitter’а не привлекая внимания санитаров

Арбитражник проkил органическbq трафик с X (Twitter) через связку с dating-офферами, используя маскировку ссылок под видеопревью. После полугода залива с марта по октябрь 2025-го он заработал скромный, но стабильный доход, внедрив динамическую генерацию страниц, обфускацию ссылок и cookie-разделение трафика для увеличения конверсии на треть. Основной вызов — постоянные баны доменом из-за обновлений Google и требований антифрода, из…

➡️ Читайте на сайте: https://aff.top/blog/kak-zarabotat-2500-s-ubt-trafika-iz-twitter-a-ne-privlekaia-vnimaniia-sanitarov

🧠 Ещё больше инсайтов → в канале AFF.top
Llama в проде: 4 вещи, которые надо проверить до первого запуска на своих GPU

Если берёте Llama под свой inference, сначала смотрите не на «качество», а на три ограничения: лицензия, контекст и throughput. Именно они чаще всего ломают экономику, а не сама модель.

— Лицензия: для коммерческого использования проверьте, можно ли вам вообще отдавать веса в прод и какие есть ограничения на продукт, бренд и redistribution. У open-source это не всегда «можно всё».

— Контекст: заявленные 128k мало что значат без теста на вашей задаче. На длинных промптах растёт latency, а на больших окнах падает стабильность ответа. Для саппорта, RAG и чата это критично.

— Квантизация: fp16 даёт максимум качества, но быстро съедает VRAM. Int4/gguf часто спасают по памяти, но могут просадить точность на сложных инструкциях и tool-use. Проверяйте на своих промптах, а не на абстрактных бенчмарках.

— Стек инференса: vLLM хорош, когда нужен высокий throughput и батчинг. llama.cpp удобен для локальных и CPU/GPU-сценариев. TGI берут, когда важны предсказуемость и интеграция. Один и тот же вес на разных рантаймах ведёт себя по-разному.

Перед запуском делайте короткий прогон: 50–100 реальных запросов, замер tokens/sec, p95 latency, VRAM и процент «плохих» ответов. Это дешевле, чем потом переделывать архитектуру.

Сначала меряйте на своих сценариях, потом выбирайте размер модели и квантизацию.
Self-hosted LLM окупается не от «дешёвых токенов», а от загрузки и качества пайплайна

Считать нужно не «стоимость модели», а полную экономику: железо, простои, обвязку, DevOps, мониторинг, квоты, бэкапы, SLA. У self-hosted главный враг — не цена GPU, а недогруз: одна и та же машина может дать 20% или 80% utilization, и разница по себестоимости токена будет в разы.

Базовая формула простая: capex на срок амортизации + электричество + администрирование / фактические токены. Если у вас низкая утилизация, выгоднее API. Если трафик ровный, запросы предсказуемые, а модель нужна постоянно — локальный inference начинает обгонять внешнего провайдера не на «магии open source», а на масштабе.

На практике экономику ломают 4 ошибки:
— берут слишком большую модель для задачи;
— не считают контекст, хотя длинный prompt съедает throughput;
— забывают про batching и получают дорогой latency;
— сравнивают цену API с GPU, но игнорируют инженерные часы.

Правильный вопрос не «могу ли я поднять Llama на своих GPU», а «какой объём запросов, какая средняя длина контекста, какой SLA и сколько часов машина реально занята». Если ответов нет — self-hosted почти всегда переоценён. Если ответы есть, окупаемость считается за 10 минут и обычно решается в пользу гибридной схемы: критичный трафик локально, всплески через API.
Qwen для продакшена: 4 проверки, без которых модель легко переоценить

Qwen часто берут за сильный English/Chinese, хороший tool-use и нормальный баланс качества к скорости. Но в проде решает не “какая модель умнее”, а как она ведёт себя на вашем контуре.

— Смотрите не только на win-rate в бенчмарках, а на ответы в вашей задаче: классификация, извлечение полей, генерация текста, агентные цепочки.
— Проверяйте длину контекста отдельно: на коротких промптах модель может быть стабильной, а на длинных начинать терять инструкции и формат.
— Тестируйте форматный контроль: JSON, таблицы, строгие шаблоны. Если парсер падает, модель для автоматики уже дорогая.
— Сравнивайте квантизацию на одном и том же наборе запросов: fp16, int8 и int4 могут дать одинаковую скорость на бумаге, но разную точность на edge-кейсах.

Отдельно смотрите на инфраструктуру: vLLM, TGI и llama.cpp дают разный trade-off по latency, batch size и расходу VRAM. Одна и та же Qwen в одном стеке может быть “рабочей лошадкой”, а в другом — упереться в память или в нестабильный throughput.

Если нужен open-source стек под автоматизацию, Qwen имеет смысл брать только после своего мини-замера: качество, скорость, цена на 1M токенов и поведение на ваших промптах. Именно эта четверка решает, будет модель приносить маржу или только красиво выглядеть в демо.
DeepSeek без маркетинга: как быстро понять, брать модель в прод или нет

У DeepSeek смотреть надо не на «умность вообще», а на 4 вещи: качество на ваших задачах, скорость инференса, длину контекста и лицензию. Для code/reasoning моделей важнее не MMLU, а стабильность на ваших промптах, длина цепочки рассуждений и то, как модель держит формат ответа под нагрузкой.

Перед запуском проверьте: — влезает ли модель в доступную VRAM без агрессивного offload; — какой throughput даёт ваш стек: vLLM, TGI или llama.cpp; — не ломается ли качество после int4; — есть ли ограничения на коммерческое использование у конкретного веса. Для 16–32 GB GPU обычно уже нужен выбор между 7B/14B и жёсткой квантизацией, а не попытка поднять «максимум по размеру».

По DeepSeek полезен простой тест: 20–50 ваших реальных запросов, один и тот же шаблон, три прогона. Смотрите не только точность, но и variance: модель может отвечать хорошо в среднем, но резко проседать на длинных входах, JSON-форматах или многошаговой логике. Если на 8k+ токенов начинается деградация, контекст «поддерживается» только на бумаге.

Для продакшена берите модель, если она выигрывает у вашей текущей не по одному бенчмарку, а по сумме: меньше цена на 1M токенов, приемлемая латентность, понятная лицензия, нормальный recall на ваших кейсах. Иначе это просто дорогой эксперимент с красивым названием.
DeepSeek для продакшена: 5 проверок, которые спасают от сюрпризов на инференсе

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

— Сначала проверь формат вывода. Для автоматизации критично, чтобы модель стабильно держала JSON, tool-calling и строгие шаблоны. Если валидатор ломается на 2–3% ответов, это уже операционная боль.

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

— Отдельно тестируй latency на batch=1 и при параллельной нагрузке. Модель может быть быстрой в демо, но проседать, когда очереди растут и KV-cache начинает съедать VRAM.

— Для self-hosted важно понять, как модель живёт в квантизации. На одних схемах она сохраняет логику, на других начинает терять точность в сложных инструкциях и длинных ответах.

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

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

Если у тебя batch по запросам, длинный контекст и важен throughput, vLLM обычно даёт лучший баланс: PagedAttention уменьшает фрагментацию KV-cache, а continuous batching держит GPU загруженной. На одной и той же модели разница с наивным сервером часто упирается не в токены/сек, а в то, сколько одновременных диалогов система переварит без провалов по latency.

TGI сильнее там, где нужен предсказуемый serving-пайплайн и аккуратная интеграция с HF-экосистемой. Удобно, если у тебя уже есть стандартизованный деплой, healthchecks, rollout и привычная observability. Но при тяжёлых промптах и скачках длины запросов надо смотреть на аллокации памяти: не всегда throughput в вакууме конвертируется в стабильный p95.

Практика такая:
— vLLM: high concurrency, mixed lengths, чат-боты, генерация пачками
— TGI: более консервативный production serving, когда важны предсказуемость и совместимость
— llama.cpp: edge, CPU, маленькие модели, gguf
— Ollama/LM Studio: локальные стенды и быстрый прототипинг, не основной прод

Если выбираешь между vLLM и TGI, сначала измерь не «скорость модели», а профиль нагрузки: среднюю длину prompt, долю длинных ответов, concurrency и target p95. Именно там обычно и лежит разница в стоимости 1M токенов.
This media is not supported in your browser
VIEW IN TELEGRAM
Как уходят из арбитража трафика: интервью с бывшим медиабайером

Интервью с арбитражником, который отработал в сфере с 2019 года и ушёл в другую профессию. Герой рассказывает о работе в Adcombo с тизерками, переходе в криптовертикаль и прямом выкупе трафика, а затем о причинах ухода: выгорание, сложности с поиском новой позиции и переоценка приоритетов. Статья развенчивает миф о лёгких деньгах в арбитраже — это обычная работа с высокими рисками, дефицитом информации и эмоциональным истощением. Выво…

➡️ Читайте на сайте: https://aff.top/blog/kak-ukhodiat-iz-arbitrazha-trafika-interviu-s-byvshim-mediabaierom

🧠 Ещё больше инсайтов → в канале AFF.top
Как выбрать Qwen под прод: 4 проверки, чтобы не утонуть в размере контекста и цене инференса

Qwen часто берут «по умолчанию», но в проде важны не название, а профиль задачи. Для short-form генерации, RAG и tool-use сначала смотрим на качество следования инструкциям, потом — на скорость на вашем железе, и только потом — на размер модели.

Проверьте 4 вещи:
Контекст: длинное окно не равно стабильная работа на полной длине. На практике деградация начинается раньше паспортного лимита.
Квантизация: int4/gguf может дать сильную экономию VRAM, но иногда ломает точность на структурированных ответах и JSON.
Throughput: сравнивайте tokens/sec не в вакууме, а на вашем batch size и вашей длине промпта.
Лицензия: для коммерции это не формальность, а фильтр до интеграции.

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

Если хотите минимизировать cost/token, тестируйте не одну модель, а связку: smaller model для рутинных запросов + larger model для сложных кейсов. Это почти всегда дешевле, чем тащить всё на одном тяжёлом inference-стеке.

Правильный выбор Qwen — это не размер модели, а совпадение модели, квантизации и сервера с вашей нагрузкой.
DeepSeek в проде: 5 проверок, без которых open-source модель легко превращается в дорогой эксперимент

DeepSeek часто берут за «дешёвую альтернативу», но в проде важны не лозунги, а четыре оси: качество, скорость, цена инференса и лицензия. Перед запуском проверьте, для чего модель реально нужна: генерация текста, код, RAG, классификация, tool-use. Одна и та же модель может быть сильной в reasoning и слабой в стабильном форматировании.

Первое — контекст. Заявленный длинный контекст не равен рабочему: после определённого объёма падает точность извлечения и растёт latency. Второе — квантизация. На int4 можно выиграть VRAM и throughput, но при сложных цепочках рассуждений и длинном prompt'е качество деградирует заметнее, чем ожидают.

Третье — фреймворк инференса. vLLM обычно даёт лучший throughput на батчах и очередях, TGI удобен для сервинга, llama.cpp выигрывает в простых локальных сценариях и на CPU/edge. Четвёртое — совместимость с вашим пайплайном: JSON-ответы, tool-calls, системные промпты, стабильность на длинных диалогах.

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

Правило простое: сначала тест на ваших промптах и вашей инфраструктуре, потом масштабирование; иначе экономия на токене быстро съедается переделками.
This media is not supported in your browser
VIEW IN TELEGRAM
ByteDance анонсировала новую версию SeeDance версии 2.5

ByteDance готовит релиз Seedance 2.5 — видеогенератора нового уровня. Главное улучшение: модель сможет создавать 30-секундные видео за один прогон без склеек, вместо нынешних 15 секунд. Добавили локальный монтаж отдельных кадров, поддержку 3D-болванок для управления камерой, возможность использовать до 50 референсов и генерацию в 4К сразу. Закрытый бета-тест идёт сейчас, открытый релиз ожидается в начале июля. Технологически это шаг вперёд, но д…

➡️ Читайте на сайте: https://aff.top/blog/bytedance-anonsirovala-novuiu-versiiu-seedance-versii-2-5

🧠 Ещё больше инсайтов → в канале AFF.top
This media is not supported in your browser
VIEW IN TELEGRAM
Codex уничтожит твой SSD за год

Разработчик обнаружил критический баг в Codex CLI от OpenAI: агент непрерывно записывает логи в локальную SQLite-базу, перезаписывая за 21 день 37 ТБ данных. При таком темпе типичный SSD объёмом 1 ТБ (рассчитанный на 600 ТБ перезаписей) выходит из строя менее чем за год. OpenAI осведомлена о проблеме, но пока не исправляет её. Пользователям остаётся либо ждать обновления, либо переключиться на альтернативные CLI-инструменты без подобных недостат…

➡️ Читайте на сайте: https://aff.top/blog/codex-unichtozhit-tvoi-ssd-za-god

🧠 Ещё больше инсайтов → в канале AFF.top
DeepSeek в проде ломается не на модели, а на неправильном inference-стеке и контексте

DeepSeek-семейство часто берут за качество на reasoning и коде, но в проде важнее не «какая модель умнее», а как она ест VRAM, как держит длинный контекст и где у вас упирается throughput.

Первый фильтр — размер и режим запуска:
— 7B/8B можно ставить на одну GPU для low-latency сценариев.
— 14B/32B уже требуют аккуратной квантизации и батчинга.
— 70B без нормального шардирования превращается в дорогой эксперимент.

Второй фильтр — движок:
— vLLM хорош, когда нужен высокий throughput и динамический batching.
— TGI удобен для типового API-сервинга и предсказуемой эксплуатации.
— llama.cpp имеет смысл для жёсткого контроля памяти и GGUF, но не для максимальной пропускной способности.

Третий фильтр — контекст. 128k в карточке модели не означает, что его можно безболезненно держать на каждом запросе. Чем длиннее prompt, тем сильнее проседают latency и эффективный batch size. Если у вас саппорт, RAG или автогенерация, ограничивайте рабочий контекст и режьте мусор до входа в модель.

Четвёртый фильтр — квантизация. Для продакшена чаще всего смотрят на 4-bit и 8-bit, но проверять нужно не «влезло ли», а:
— не деградирует ли tool use;
— не ломается ли JSON;
— не растёт ли доля пустых или повторяющихся ответов.

Если DeepSeek нужен как рабочая лошадь, начинайте не с максимальной модели, а с минимальной, которая проходит ваши QA-метрики. Это почти всегда даёт лучший баланс качества, скорости и стоимости.
Qwen для продакшена: 4 проверки, без которых модель легко превращается в дорогой шум

Qwen часто берут за сильный multilingual и неплохой code. Но в проде решает не «умная демка», а связка качество/скорость/цена/лицензия. Перед внедрением проверьте 4 вещи: задачи, где модель реально должна быть сильной; длину контекста, которая не ломает ответы; формат вывода, который можно парсить без костылей; и ограничения лицензии для коммерческого использования.

На практике Qwen хорошо заходит в:
— классификацию и маршрутизацию запросов;
— extraction в JSON;
— черновики ответов на нескольких языках;
— code-assist, если есть строгие тесты на синтаксис и unit-check.

Слабое место почти всегда одно и то же: слишком длинный контекст без контроля качества. Если вы пихаете в prompt весь диалог и ещё документы, модель начинает терять приоритеты, а latency растёт нелинейно. Для продакшена лучше резать контекст, делать retrieval и держать отдельный слой валидации ответа: schema check, regex, пост-обработку.

Если нужен стабильный API без OpenAI-зависимости, Qwen имеет смысл только вместе с нормальным inference-стеком: vLLM для throughput, TGI для предсказуемости, llama.cpp для edge/GGUF. Сначала измеряйте tokens/sec и rate of invalid output, потом уже выбирайте размер модели и квантизацию.

Правило простое: Qwen выбирают не за «магическую» LLM-умность, а за управляемость. Если у вас есть тесты, схема ответа и метрика качества, модель начинает приносить деньги; если нет — она просто красиво пишет текст.
This media is not supported in your browser
VIEW IN TELEGRAM
Google ужесточает модерацию финансовой вертикали

Google ужесточает модерацию финансовых офферов в ЕС и ЕЭЗ, введя двухэтапную верификацию через G2 Risk Solutions и Google Ads. Проверка затронет 24 страны, включая Австрию, Польшу, Нидерланды и другие члены союза. На прохождение модерации отводится 30 дней — за это время некоторые связки успеют отработать до вступления требований в силу. Для арбитражников это означает необходимость подготовиться к усложнению процесса запуска финансовых кампаний …

➡️ Читайте на сайте: https://aff.top/blog/google-uzhestochaet-moderaciiu-finansovoi-vertikali

🧠 Ещё больше инсайтов → в канале AFF.top
vLLM и TGI: как не ошибиться с выбором сервера под open-source LLM

Если нужен быстрый и предсказуемый inference, выбор обычно сводится к двум лагерям: vLLM и TGI. Оба умеют раздавать Llama / Qwen / DeepSeek в проде, но оптимизируют разные узкие места.

vLLM сильнее там, где важны высокий throughput и плотная утилизация GPU. Его сильная сторона — эффективное batch’ирование и работа с длинными очередями запросов.
TGI часто берут за более «ровный» production-опыт: понятные механики деплоя, удобная интеграция в типовой API-стек, предсказуемое поведение под нагрузкой.
— Если у вас много коротких запросов, главный KPI — tokens/sec на карту. Если запросы длинные и контекст тяжёлый — смотрите не только на скорость генерации, но и на стабильность latency p95.

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

Для маленькой команды правило простое: если нужна максимальная плотность и вы готовы тонко настраивать сервер — начинайте с vLLM. Если важнее типовой production-путь, простота сопровождения и меньше ручной возни — смотрите на TGI.

Лучший тест — не «какой сервер быстрее вообще», а «какой даёт нужный p95 latency и стоимость 1M токенов на вашем профиле запросов».
This media is not supported in your browser
VIEW IN TELEGRAM
Fable 5 скоро вернётся в публичный доступ

В исходном коде Claude Code обнаружены упоминания о возвращении модели Fable 5 в публичный доступ с изменённой моделью распространения — её больше не потребуется покупать отдельно, вместо этого будет применяться недельный лимит как для других моделей. Если информация подтвердится, пользователи платных тарифов смогут использовать Fable 5 в рамках своих подписок. Причины снятия ограничений по национальной безопасности остаются неясными. Хотя это п…

➡️ Читайте на сайте: https://aff.top/blog/fable-5-skoro-vernetsia-v-publichnyi-dostup

🧠 Ещё больше инсайтов → в канале AFF.top
Self-hosted выгоден не тогда, когда токен дешевле, а когда у вас есть стабильный поток

Считать надо не «цена API vs своя GPU», а полную себестоимость: железо, амортизация, электричество, хранение весов, оркестрация, запас по отказам, инженерное время. Если модель простаивает, self-hosted почти всегда проигрывает. Если нагрузка ровная и предсказуемая — экономика быстро меняется.

Для расчёта берите 3 метрики:
— tokens/sec на одной GPU при вашем контексте
— среднюю загрузку за сутки, а не пик
— долю запросов, которые реально требуют LLM, а не шаблон
Если у вас 15–20% трафика можно увести в правила, rerank или маленькую модель, дорогой инференс перестаёт быть базой.

Главная ошибка — покупать GPU «под запас», а потом кормить её одним чатом. Вторая ошибка — не считать деградацию на длинном контексте: 32k и 128k на практике дают разную пропускную способность и разный cost per request. Третья — игнорировать latency tail: если p95 падает, бизнесу всё равно на красивый средний throughput.

Считайте точку окупаемости через месячный объём токенов и реальную утилизацию, а не через цену одной тысячи запросов. Если ваш пайплайн уже даёт постоянную нагрузку, self-hosted превращается из «дорого» в «контролируемо».
vLLM или TGI: как выбрать движок для инференса без сюрпризов в проде

vLLM берут, когда нужен высокий throughput на длинном контексте и много параллельных запросов. Его сильная сторона — paged attention и агрессивная работа с KV-cache: на одной и той же GPU он обычно лучше держит плотную очередь запросов, чем наивный сервер.

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

Сравнивать их надо не по «какая модель запускается», а по нагрузке:
• много коротких чатов — смотри p50/p95 latency
• длинные промпты и RAG — смотри, как быстро растёт задержка при росте контекста
• высокая конкуренция запросов — считай tokens/sec на GPU, а не только время первого токена
• ограниченная VRAM — тестируй квантизацию и реальный размер батча

Типичная ошибка — мерить только одиночный запрос. В проде один красивый ответ ничего не значит: важнее, сколько одновременных сессий выдерживает сервер без провала latency и OOM. Ещё одна ошибка — не смотреть на длину генерации: движок, который быстрый на 64 токенах, может сильно просесть на 512.

Правило простое: если у тебя упор в параллелизм и утилизацию GPU, начинай с vLLM; если нужен более консервативный и простой путь в инфраструктуре — смотри TGI. А финальный выбор делай только на своём профиле нагрузки, а не на чужом бенчмарке.
vLLM и TGI ломаются не на железе, а на неправильной нагрузке и промптах

Если модель одна и та же, разница между vLLM и TGI чаще всего упирается в профиль трафика: короткие чаты, длинный контекст, много параллельных сессий, стриминг или batch. Перед выбором проверьте три вещи: среднюю длину prompt, среднюю длину completion и пик одновременных запросов.

vLLM обычно выигрывает там, где важны высокий throughput и плотная загрузка GPU: paged attention лучше переживает фрагментацию KV-cache, а continuous batching помогает держать карту занятой. TGI удобнее, когда нужен более предсказуемый продовый сервис, аккуратный streaming и проще контроль вокруг inference-пайплайна.

Практическая ошибка — сравнивать их на одном коротком промпте. На 100–200 токенах разница может быть почти незаметна, а на длинном контексте и очереди из десятков запросов картина меняется: один стек начинает упираться в память, другой — в scheduler. Смотрите не только tokens/sec, но и p95 latency, OOM rate и время ожидания в очереди.

Если строите свой API под прод, тестируйте оба стека на реальном распределении запросов, а не на синтетике. Побеждает не «самый быстрый сервер», а тот, который держит ваш профиль нагрузки без деградации качества и с предсказуемой стоимостью инференса.
This media is not supported in your browser
VIEW IN TELEGRAM
Chat GPT-5.6 будут выдавать лишь избранным

США ограничивают публичный доступ к новым ИИ-моделям: теперь его выдают только проверенным пользователям после обязательной 30-дневной процедуры верификации. Сэм Альтман называет это самым быстрым путём к публичному релизу. Эффективность меры вызывает сомнения — китайские разработчики традиционно копируют модели в течение суток после выхода.

➡️ Читайте на сайте: https://aff.top/blog/chat-gpt-5-6-budut-vydavat-lish-izbrannym

🧠 Ещё больше инсайтов → в канале AFF.top