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

В конце мая 2026 года Великобритания санкционировала криптовалютные сервисы за работу с Россией, включая биржи Huobi Global и Exmo. Пользователи, получившие крипту от этих платформ, поймали метку «опасные источники» при AML-проверке, что затрудняет обмен и может привести к блокировке средств. При возникновении проблем нужно немедленно писать в поддержку с доказательствами легальности транзакций: скриншотами P2P-сделок, квитанциями от партнёрок …

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

🔗 Рекомендуем @oss_saas_desk — соседи по теме (oss).

В России введут комиссию за обмен USDT

Российский законопроект впервые чтения вводит регулирование криптовалют через пять категорий организаций и требует налогообложения прибыли криптообменников. Закон затронет популярные активы типа USDT и BNB, контролируемые недружественными странами. Основная цель — обязать обменники делиться доходами с бюджетом через комиссии и экономические стимулы, что в итоге увеличит затраты для рядовых пользователей и может стимулировать переход на альтернат…

➡️ Читайте на сайте: https://aff.top/blog/v-rossii-vvedut-komissiiu-za-obmen-usdt

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

vLLM и TGI ломаются не на модели, а на плохом планировании памяти и контекста

Если у вас одинаковая Llama/Qwen/DeepSeek, разница между vLLM и TGI часто упирается не в «качество ответа», а в то, как сервер держит KV-cache, батчинг и длинный контекст. Ошибка №1 — запускать 8k-32k контекст на машине, где память рассчитана только на короткие запросы: сначала всё быстро, потом начинается фрагментация и резкий провал throughput.

vLLM обычно берут, когда нужен высокий throughput на mixed workload: много коротких запросов, параллельные сессии, динамический batching, непрерывная подача токенов. TGI чаще удобнее, если важнее предсказуемость, стабильная интеграция и привычный production-пайплайн. На практике разница видна в трёх вещах: сколько токенов/sec держится под нагрузкой, как растёт latency p95 при росте concurrency и насколько болезненно сервер переживает длинные промпты.

Чек-лист перед выбором:
— если запросы короткие и их много, сначала смотрите на batching и prefill throughput;
— если нужен длинный контекст, считайте не только VRAM под веса, но и запас под KV-cache;
— если у вас несколько моделей, важнее изоляция и очереди, чем абсолютный peak speed;
— если batch size пришлось уменьшать вдвое ради стабильности, вы уже потеряли часть экономии.

Главное правило: выбирают не «лучший сервер», а сервер под профиль нагрузки. Для арбитражной автоматизации чаще выигрывает тот стек, где p95 latency предсказуемее, а память не заканчивается на первом же длинном диалоге.

Mistral и Gemma: как выбрать модель под прод без лишнего разочарования

Если нужен open-source LLM для продукта, Mistral и Gemma часто попадают в один список, но задача у них разная. Сравнивать их нужно не по хайпу, а по четырём осям: качество, скорость, цена инференса и лицензия.

— Mistral обычно выбирают, когда важны сильный instruction-following и хороший баланс latency/качество. Для коротких и средних контекстов она часто проще в эксплуатации: меньше сюрпризов в генерации, удобнее в API-обвязке, легче масштабировать через vLLM или TGI.

— Gemma чаще берут там, где нужен компактный inference-профиль и предсказуемая работа на ограниченном железе. На одной GPU разница в throughput между 2B, 7B и 9B классом ощущается сильнее, чем разница в «названии модели»: иногда более маленькая Gemma даёт лучший cost/token, чем более крупная Mistral.

Ключевая ошибка — выбирать модель только по бенчмарку на одном датасете. В проде важнее:
• стабильность на длинном промпте
• устойчивость к шаблонным инструкциям
• поведение на русскоязычных и смешанных запросах
• совместимость с квантизацией int4/gguf без заметной деградации

По лицензии тоже нельзя смотреть поверхностно: для коммерции проверяйте условия именно той ветки модели, которую собираетесь ставить в прод, включая ограничения на redistributing и use-case.

Если задача — чат, ассистент, RAG и генерация шаблонного текста, начинайте с той модели, которая лучше проходит ваши внутренние тесты на latency и качество, а не с той, у которой громче имя.

В App Store снова появилось приложение Telegram для Apple Watch

Telegram вернул приложение для Apple Watch в App Store с поддержкой сообщений, голосовых и текстовых сообщений, гифок и стикеров. После переиздания приложения в сторе можно ожидать запуска таргетированной рекламы в Telegram ADS, что открывает возможности для тестирования MVA-приложений на iOS через новый канал трафика.

➡️ Читайте на сайте: https://aff.top/blog/v-app-store-snova-poiavilos-prilozhenie-telegram-dlia-apple-watch

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

DeepSeek в проде ломается не на модели, а на плохом пайплайне инференса

DeepSeek часто берут ради сильного reasoning и хорошего соотношения качество/цена, но в реальном сервисе решает не только чекпоинт.

— Сначала проверь формат задачи: если это короткие ответы, то длинный контекст и тяжелый reasoning только съедают throughput.
— Для batch-генерации и очередей почти всегда выгоднее vLLM; если нужен простой локальный запуск или CPU/GPU-микс, смотри в сторону llama.cpp.
— Квантизация ниже fp16 обязана проходить свой набор тестов: на code, math и extraction модели могут вести себя по-разному.
— Для API-сервиса отдельно меряй prompt prefill и decode, а не только общий tokens/sec: именно prefill часто убивает latency на длинных промптах.
— Не смешивай в одном endpoint задачи с разной длиной контекста без лимитов: один «монстр»-запрос портит очередь всем остальным.

Практика простая: сначала замерь качество на своих задачах, потом throughput на своем железе, и только после этого решай, какой DeepSeek и в какой квантизации пускать в прод.

vLLM и TGI ломаются не на модели, а на неправильном профиле нагрузки

Если у тебя короткие запросы, высокий параллелизм и нужен агрессивный batching — vLLM обычно даёт выше throughput за счёт paged attention и более гибкого управления KV-cache. Если важнее предсказуемость, интеграция в уже собранный inference-пайплайн и контроль за serving-логикой — TGI часто проще в эксплуатации.

Смотри не на «лучший фреймворк», а на три числа: tokens/sec на одну GPU, p95 latency и объём контекста при реальной очереди. В синтетике оба сервера выглядят бодро, но при длинных промптах и mixed load начинает решать не маркетинг, а то, как движок режет память, собирает batch и пережёвывает prefill.

Практика такая:
• vLLM — если у тебя много одновременных сессий, streaming и постоянная смена длины запросов.
• TGI — если важны стабильность, понятный deployment и интеграция с HF-стеком.
• Оба нужно тестировать на своём распределении: короткие саппорт-реплики, длинные RAG-запросы, tool-calls, несколько одинаковых пиковых окон.

Не делай вывод по одному прогону на 512 токенов. Прогони хотя бы 3 профиля: short chat, long context, burst traffic. Тогда выбор между vLLM и TGI станет не религией, а инженерным решением.

Арбитраж на вертикаль астрологии: как начать с ней работать

Астрология — белая вертикаль с низким порогом входа для CPA-арбитража. Можно создать собственного астробота через конструктор или нейросеть, подключив платежи через сервисы вроде Tribute, либо работать через партнёрки с готовыми ботами и SP-офферами. Также доступны нишевые площадки типа Bongacams с эзотериками (A. W. Empire). Трафик заливают со стандартных источников без клоачинга — Яндекс Директ, МТС Ads, ВК. Вертикаль привлекательна скромной к…

➡️ Читайте на сайте: https://aff.top/blog/arbitrazh-na-vertikal-astrologii-kak-nachat-s-nei-rabotat

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

DeepSeek в проде: где модель реально экономит токены, а где её лучше не ставить

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

— Для structured generation и code-heavy сценариев сильнее всего обычно работает связка: умеренный размер модели + жёсткий system prompt + low temperature.
— Для длинных диалогов важнее не «128k на бумаге», а реальная деградация после нескольких десятков тысяч токенов: у многих моделей качество ответов падает раньше, чем заканчивается окно.
— Для RAG DeepSeek полезен там, где нужен хороший follow-up по найденным кускам текста, но retrieval всё равно решает больше, чем сама LLM.
— Для массового API-сервиса считайте не только качество, но и throughput на вашей GPU: если модель даёт меньше токенов/sec, дёшево на токен она может стать дорогой на инфраструктуру.

Практика такая: сначала гоняете модель на своём наборе промптов, потом сравниваете quality / latency / cost / license. Если задача — чат и извлечение фактов, берите smaller variant. Если нужен сложный reasoning или код с многослойным контекстом, проверяйте старшую, но обязательно на своём железе.

Главная ошибка — выбирать DeepSeek по общему впечатлению. В проде выигрывает не «лучшая модель», а та, у которой совпали качество ответа, скорость и стоимость обслуживания.

Llama в проде: 6 проверок, которые спасают от дорогого и медленного инференса

Llama часто берут “по умолчанию”, а потом удивляются просадке по latency и качеству. Перед запуском проверьте четыре вещи: размер контекста, тип квантизации, формат сервинга и реальную длину промптов в вашем трафике. Если 90% запросов укладываются в короткий контекст, не переплачивайте за огромный KV-cache и лишнюю VRAM.

Для 8B-моделей рабочая база — fp16 для качества, int8 как компромисс, int4/gguf для дешёвого CPU или одной GPU с ограниченной памятью. На практике важнее не “максимальный размер”, а tokens/sec на вашей карте и стабильность под параллельной нагрузкой. vLLM обычно выигрывает на батчинге, TGI удобен в продакшене, llama.cpp нужен там, где критична автономность.

Отдельно смотрите на prompting: у Llama чувствительность к шаблону ответа выше, чем кажется. Один и тот же чекпоинт может давать разный output при смене system prompt, stop tokens и температуры. Если делаете fine-tune под нишу, сначала фиксируйте формат входа и метрику ошибки, а уже потом крутите LoRA.

Ещё одна типовая ошибка — сравнивать модель в вакууме. Считайте не только качество, но и стоимость 1M токенов на вашем железе, p95 latency, объём памяти под контекст и цену простоя. Брать Llama имеет смысл там, где вы готовы управлять инференсом как продуктом, а не как “чёрным ящиком”.

DeepSeek для продакшена: как не промахнуться с выбором модели и инференса

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

— Для чата и RAG важны не только ответы, но и поведение на длинном контексте: у больших контекстов деградация начинается раньше паспортного окна.
— Если нужен поток запросов, сравнивайте не «качество на глаз», а tokens/sec, p95 latency и max batch size на своём железе.
— Для задач с жёсткой стоимостью токена считайте throughput на одной GPU в разных квантизациях: fp16, int8, int4. Разница по экономике часто важнее разницы в бенчмарке.
— Если планируется fine-tune, проверьте, как модель держит LoRA на вашем домене: у reasoning-моделей иногда проседает стиль, даже если метрика на тесте растёт.
— Лицензия и режим использования важнее красивого демо: сначала проверяем, можно ли модель легально встраивать в коммерческий стек.

Практика простая: тестируйте DeepSeek не на одном промпте, а на пачке из 50–200 реальных запросов, где есть короткие, длинные и «грязные» кейсы. И только после этого решайте, брать ли её как основную или оставить для узкого класса задач.

vLLM и TGI ломают prod по-разному: где у каждого свой скрытый лимит

Если у тебя один и тот же промпт на 8k летает, а на 32k внезапно сыпется latency — проблема часто не в модели, а в сервере. vLLM и TGI оба умеют отдавать LLM в проде, но оптимизируют разные узкие места: один чаще выигрывает на динамическом батчинге и высокой утилизации GPU, другой — на предсказуемом пайплайне и простом прод-обвязке.

Смотри на 4 вещи:
— throughput в tokens/sec на одной GPU, а не “сколько RPS держит”
— p95/p99 latency при смешанном трафике, а не только среднее
— поведение на длинном контексте: 16k/32k/64k часто деградируют неравномерно
— memory fragmentation: если сервис живёт под постоянным churn запросов, часть VRAM просто уходит в мусор

vLLM обычно лучше, когда важна плотная загрузка железа и много параллельных сессий с разной длиной промптов. TGI удобнее, когда нужен более прямолинейный деплой, стабильный API и меньше сюрпризов в эксплуатационке. Но оба проиграют, если ты не ограничил max_tokens, не настроил batching и не посчитал, сколько контекста реально нужно бизнес-задаче.

Правило простое: сначала замерь на своём профиле трафика, потом выбирай движок. Иначе можно получить “быстрый” сервер, который в проде сжирает VRAM, режет контекст и делает cost/token хуже, чем у внешнего API.

Mistral и Gemma в проде: как выбрать модель под свои GPU и не убить latency

Если нужен open-source стек без OpenAI-зависимости, Mistral и Gemma закрывают разные задачи. Сначала смотрим не на «качество в вакууме», а на 4 оси: качество, скорость, цена инференса и лицензия.

• Mistral обычно удобнее там, где важны короткий latency и хороший instruction-following на средних контекстах.
• Gemma чаще берут, когда нужен аккуратный баланс качества и размера модели, особенно для локального запуска на ограниченной VRAM.
• Для обеих семейств критичен формат инференса: vLLM даёт лучший throughput на батчах, TGI удобен для сервинга, llama.cpp выигрывает на CPU и GGUF, но теряет в пропускной способности на больших нагрузках.

Типовая ошибка — сравнивать fp16 и int4 как будто это одна и та же постановка. Квантизация меняет не только память, но и поведение на длинном контексте, особенно если у вас RAG, tool-calling и длинные промпты. На практике сначала проверяют: помещается ли модель в VRAM с запасом под KV-cache, а уже потом гонят бенчмарк.

Для продакшена полезен такой порядок:
— 1) выбрать целевой сценарий: чат, извлечение, классификация, генерация креативов;
— 2) измерить tokens/sec на одной GPU в вашем фреймворке;
— 3) прогнать промпты с длинным контекстом;
— 4) сравнить стоимость 1M токенов с self-hosted альтернативой.

Если модель не укладывается в ваш SLA по latency, «лучшее качество» становится бесполезным. Брать надо ту, что стабильно держит ваш сценарий, а не абстрактный бенчмарк.

DeepSeek в проде ломается не на «качестве», а на неправильном режиме запуска

DeepSeek-R1 и его дистилляты часто берут за reasoning, но в реальном пайплайне решают три вещи: контекст, скорость и стабильность промпта. Если задача — короткий ответ или строгий JSON, не гоняйте модель в цепочке размышлений без нужды: длинный hidden-thought съедает токены и увеличивает latency.

Для self-hosted важны не «размер модели», а режим инференса:
— vLLM: лучший выбор, если нужен высокий throughput и батчинг;
— TGI: удобен для стандартного serving и контроля очереди;
— llama.cpp: берите для CPU/GGUF и экономии VRAM, но не ждите рекордной скорости;
— SGLang/аналогичные движки: полезны, когда много длинных диалогов и сложный роутинг.

На практике DeepSeek лучше ставить как отдельный слой: один маршрут для reasoning, другой — для extraction и классификации. Иначе вы платите за дорогую генерацию там, где хватило бы компактной модели. Для RAG это особенно заметно: retrieval должен быть дешёвым, а reasoning — включаться только на спорных кейсах.

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

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

DeepSeek для продакшена: как не промахнуться с размером, контекстом и квантизацией

DeepSeek-модели часто берут за «умную» генерацию и сильный код, но в проде смотреть надо не на хайп, а на 4 вещи: качество, скорость, цена, лицензия.

— Если нужен быстрый чат/автоматизация, маленькая модель на int4 часто выгоднее большой в fp16: latency ниже, GPU проще, а throughput выше.
— Для длинного контекста не верьте рекламному числу вслепую: после определённого окна качество начинает падать, особенно на многошаговых задачах и RAG без хорошего ретривала.
— Для кодовых задач важнее не только perplexity, но и поведение на репозиториях: генерация патчей, соблюдение API, устойчивость к длинным промптам.
— Если берёте модель под API-сервис, сразу считайте токены: vLLM даёт хороший throughput на батчинге, llama.cpp — проще для CPU/GPU-микса и edge, TGI удобен, когда важна стандартная эксплуатация.
— Квантизация — не “дешёвый fp16”, а отдельный режим с потерей качества. Для extraction и классификации это обычно терпимо, для сложного reasoning — уже риск.

Перед внедрением прогоните свой мини-набор: 20–50 реальных запросов, 3 режима инференса, 2 квантизации. И только потом решайте, брать ли модель в прод.

Модель, которая красиво отвечает в демо, может быть дорогой и нестабильной в эксплуатации.

Llama для продакшена: 5 проверок до запуска, чтобы не сжечь бюджет

Llama часто берут как «дешёвую замену API», но в проде модель ломается не на бенчмарке, а на деталях инференса. Смотрите не только на качество, а на 4 оси: лицензия, длина контекста, latency и стоимость 1M токенов на вашем железе.

1) Проверьте лицензию на коммерческое использование и ограничения по продукту. Для self-hosted это критично: одна и та же архитектура может быть ок для внутреннего инструмента, но спорной для внешнего SaaS.

2) Тестируйте не «среднюю скорость», а p95 latency при вашем промпте и batch size. Для Llama на одной GPU разница между fp16, int8 и int4 может быть не только в памяти, но и в стабильности длинных ответов.

3) Не верьте заявленному 128k без собственного прогона. На длинном контексте важны KV-cache, rope scaling и деградация качества после определённой длины. Если модель начинает терять инструкции на середине диалога — это не баг приложения, а предел режима.

4) Сравнивайте не только vLLM, но и TGI, llama.cpp, Ollama: где-то выиграете в throughput, где-то в простоте деплоя, а где-то — в цене владения на слабом железе.

Если Llama не проходит ваш реальный сценарий по latency и памяти, «открытость» не спасает. Брать стоит только после прогона на своих промптах, своих длинах и своей экономике.

Anthropic отменили доступ к Claude Fable 5

Fable 5, нейросетевая модель, которая должна была революционизировать индустрию, была отключена через три дня после релиза из-за ограничений на использование для граждан США и найденной уязвимости в безопасности. Компания не смогла технически реализовать географические ограничения и вынуждена была отозвать публично опубликованную модель со всех аккаунтов — первый такой прецедент. Это может стать предвестником нового тренда, когда компании будут …

➡️ Читайте на сайте: https://aff.top/blog/anthropic-otmenili-dostup-k-claude-fable-5

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

Арбитраж трафика для новичков в 2026: стоит ли начинать?

Три опытных арбитражника — Дима Leto, Михаил Харди и Роман Croyman — развенчивают миф о лёгких деньгах в CPA-арбитраже. Главный вывод: успех требует серьёзного бюджета (минимум $1000, реально больше), года работы с убытками и постоянного тестирования. Маркетинговое образование помогает, но не критично — важнее опыт в конкретной нише. Кейсы с миллионными прибылями создают завышенные ожидания, но без них новичок не верит в возможность вообще. Лучш…

➡️ Читайте на сайте: https://aff.top/blog/arbitrazh-trafika-dlia-novichkov-v-2026-stoit-li-nachinat

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

vLLM или TGI: как не выбрать движок инференса вслепую и не потерять throughput

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

— vLLM обычно выигрывает там, где важны continuous batching и высокая утилизация GPU на mixed workload.
— TGI чаще выбирают за более предсказуемую эксплуатацию, удобный production-пайплайн и понятную интеграцию вокруг Hugging Face-экосистемы.
— На коротких запросах разница может быть небольшой, а на длинном контексте и большом concurrency уже решает scheduler, KV-cache и политика батчинга.

Смотрите на 4 метрики: tokens/sec на GPU, p95 latency, стабильность под пиками и расход VRAM на один активный диалог. Если модель ест память агрессивно, любой красивый throughput быстро превращается в OOM.

Отдельно проверьте:
— насколько движок держит большой batch без деградации;
— как ведёт себя при stream-ответах;
— можно ли ограничить max context и max new tokens на уровне сервера;
— что будет при рестарте и прогреве модели.

Для продакшена критичен не максимальный, а устойчивый throughput. Один и тот же LLM может выглядеть одинаково на бенчмарке, но в реальном трафике один движок даст меньше хвостов по latency и меньше срывов по памяти.

Если у вас смешанный поток запросов и важна загрузка GPU до упора — начинайте с vLLM. Если важнее простая и предсказуемая эксплуатация в Hugging Face-стеке — смотрите в сторону TGI.

vLLM или TGI: 4 ошибки при выборе inference-стека для Llama и Qwen

Если нужен высокий throughput на батчах и много одновременных запросов, vLLM обычно выигрывает за счёт paged attention и агрессивного continuous batching. Если важнее предсказуемость, tight control над пайплайном и интеграция в Hugging Face-экосистему, TGI часто проще в эксплуатации. Ошибка №1 — сравнивать их на одном промпте: оба стека раскрываются только под нагрузкой.

Ошибка №2 — игнорировать длину контекста. На 8k всё выглядит «быстро», но при 32k+ растёт KV-cache, и узкое место уезжает либо в VRAM, либо в деградацию latency. Для длинных диалогов и RAG сначала считайте память: размер модели, число параллельных сессий, max_tokens, затем уже выбирайте сервер.

Ошибка №3 — мерить только tokens/sec. Для продакшена важнее p95 latency, время до первого токена и поведение под burst-трафиком. vLLM обычно лучше держит микс коротких и длинных запросов, TGI часто стабилен на ровном потоке, но хуже переносит резкие пики без правильной очереди и лимитов.

Ошибка №4 — запускать FP16 там, где int4 или int8 уже закрывают задачу. На одной GPU квантизация часто даёт кратный рост пропускной способности и позволяет поднять batch size без смены железа. Для саппорта, классификации и черновиков текста это обычно выгоднее, чем «максимальное качество любой ценой».

Выбирайте стек не по хайпу, а по профилю нагрузки: если важны максимальный throughput и гибкость — стартуйте с vLLM; если нужен аккуратный production-пайплайн вокруг HF-моделей — смотрите TGI.