Выжать больше из локальных LLM. Ollama медленнее llama.cpp в 3 раза. UD_Q4_K_XL лучше чем Q4_K_M, а вес тот же и т.д

Тут как-то до сих пор нет консенсуса. Если это Dense - то однозначно работает, если MoE за счет дополнительных GPU целиком влезает, то работает, но ncmoe компенсирует разницу.

А вот если MoE не влезает целиком, то добавление второй GPU пока не ясно - дает эффект или нет. Зависит от разных факторов. В моем случае результат усредняется. И нужно учитывать, что 2 GPU это не VRAM1 + VRAM2, общий расход памяти на контекст будет выше, чем на одной карте.

В последнее время не было больших Dense, поэтому старая Llama-3.3-70B-Instruct-UD-Q3_K_XL 34.9 Гб, просто из расчёта чтобы влезло на 2 GPU:

• 5090 -ngl 81: 10 t/s

• 4060 -ngl 32: 2.4 t/s

• 5090 + 4060 auto: 17 t/s

• 5090 + 4060 -ts 5,1: 23 t/s

Qwen3.5-122B-A10B-UD-Q4_K_XL 74 Гб:

• 5090: 23 t/s

• 4060: 12 t/s

• 5090 + 4060: 18 t/s

Qwen3.5-122B-A10B-UD-IQ2_XXS 35 Гб:

• 5090: 67 t/s

• 4060: 19 t/s

• 5090 + 4060 auto: 64 t/s.

• 5090 + 4060 -ts 5,1: 79 t/s

Везде 4k контекст и Win10. У меня 4060 подключена через pcie x1, через nvtop можно посмотреть интенсивность обмена, она довольно низкая для MoE:

ncmoe

Для Dense еще менее интенсивна:

dense

Вообще, ширина канала нужна для Tensor Parallelism, который дает ~2х ускорение на двух GPU, где происходит интенсивный обмен тензорами. В llama.cpp используется Pipeline Parallelism - сначала работает первая GPU, потом вторая GPU, между ними обмен только конечных слоев, которые на конкретной GPU, что не особо интенсивно, но и ускорение только за счет дополнительной быстрой памяти, а не одновременной работы двух GPU.

Хорошая поддержка TP в vllm и sglang. В ik_llama есть режим -sm graph, который делает почти тоже что TP. В llama.cpp есть -sm tensor, но он работает пока не очень, хуже чем sm graph.

Локальные LLM на слабом железе — что ставить, как запустить, чего ждать

Выжать больше из локальных LLM. Ollama медленнее llama.cpp в 3 раза. UD_Q4_K_XL лучше чем Q4_K_M, а вес тот же и т.д

Пробуем использовать бесплатные ИИ для написания кода

Кстати, кто-нибудь пользовался deepseek coder? Какие впечатления?

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

2 недели назад вышла Gemma4, в размере 31B годная, в размере 26B-A4B слабая, но знает много анекдотов. Но модель 31B что это Dense модель, то есть должна целиком влезать в VRAM для нормальной скорости, в то время как MoE модель можно распределить между VRAM и RAM в cmoe режиме (не обычная выгрузка слоев ngl, cmoe работает по другому) и получить хорошую скоростью, этот режим по умолчанию включен в llama.cpp, но его нет в ollama.

Вчера вышла Qwen3.6-35B-A3B, и это хороший уровень для такого размера. Даже квантованная Qwen3.6-35B-A3B-UD-Q2_K_XL работая с opencode или qwen code не теряет контекст на 128к, но лучше, конечно, UD-Q4_K_XL.

Для пример попросил UD-Q2_K_XL сделать реплику Win11, 1 запрос, результат 40к токенов. На 4060 16гб скорость 60 t/s. Всё двигается, шевелится, плавное, анимированное:

Qwen3.6-35B-A3B-UD-Q2_K_XL, 4060 16гб, 60 t/s

Как отключить reasoning у локального DeepSeek-R1 и не сойти...

DeepSeek-R1-Distill-Qwen-32B - это был экспериментальный файнтюн Qwen2.5-32B, с плохим качеством. Если нужно отключить мышление, то проще взять именно Qwen2.5-32B, где и качество выше и размышление нормально отключается. Но вообще, с тех пор уже вышло 4 поколения новых Qwen моделей, которые и лучше и легче. И удобнее перейти на gguf, там есть и квантование, и размышление отключается 1 строчкой --reasoning off (и ещё несколькими способами).

Если сравнивать именно с Distill-Qwen-32B, то можно посмотреть даже на мелкие Gemma4 E4B или Qwen3.5 4B, которые очень хороши для своего размера.

Вчера вышла качественная Qwen3.6-35B-A3B сделанная на MoE архитектуре, активных параметров всего 3B, модель очень быстрая, а для запуска хватит 4Гб VRAM. Или свежие MoE Gemma4-26B-A4B и Dense Gemma4 31B, которые вышли 2 недели назад.

Подробнее: Запускаем GPT-OSS-120B на 6 Гб GPU и ускоряем до 30 t/s. Вам нужна RAM, а не VRAM. Параметр -cmoe для ускорения MoE LLM

Alibaba перевела Qwen Code на платную модель с 15 апреля

Не очень понятно как у вас модель весом 91,5Гб (unsloth/Qwen3.5-122B-A10B-GGUF) крутится на карте 24Гб

Нужен режим работы cmoe (не просто выгрузка слоев ngl). Вот тут подробнее: Запускаем GPT-OSS-120B на 6 Гб GPU и ускоряем до 30 t/s. Вам нужна RAM, а не VRAM. Параметр -cmoe для ускорения MoE LLM

В актуальных версиях llama.cpp, по умолчанию включен режим fit, чего нет в ollama и lm studio, fit сам определяет оптимальные параметры загрузки модели, и для MoE он включает режим ncmoe, чтобы максимально использовать GPU для ускорения, остальное крутится в RAM. В статье про это тоже есть.

Запускаю Gemma 4 локально в LM Studio: 51 токен/с и Claude Code без интернета

Модель 31B Q8 тоже не очень - посмотрите ее объяснение своего правильного ответа

У вас не оригинальная Gemma4 31B, а Gemma-4-31B-it-uncensored-heretic над которой провели лоботомию с непредсказуемой деградацией качества. Зануление весов может работать в каких-то сценариях, но общее качество всё равно просядет, особенно на не английском языке. Компенсировать это через высокий Q8 квант не получится, это просто надо учитывать.

Но помимо этого, в llama.cpp на старте было не правильно реализовано внимание у Gemma4, несколько дней назад это исправили, плюс Google выложил правильный шаблон чата который вшит в gguf.

Надо перекачать gguf и скачать свежую llama.cpp. Увеличилось и качество ответов, и модель начала нормально работать в агентах, и теперь расход памяти под контекст не такой огромный, как было вначале.

С размышлением может в кванте UD-Q2_K_XL:

Без размышления правильно начинает отвечать с UD-Q3_K_XL:

Gemma4 31B UD-Q3_K_XL

UD квантование - это динамическое квантование, в котором тензоры внимания квантуются выше, за счет этого, например, UD-Q3_K_XL становится примерно равен по качеству с привычным Q4_K_M, но весит меньше на несколько Гб, а сравнимый по весу UD-Q4_K_XL будет лучше обычного Q4_K_M.

Свой ИИ без облаков: практический гайд по llama.cpp + Qwen

8ГБ ОЗУ и 1ГБ GPU. Какую версию лучше поставить?

Свежие Qwen3.5-4B и Gemma-4-E4B. Помимо текста, у этих моделей есть Vision модуль, можно распознавать, переводить, создавать макеты на основе изображений.

ruGPT3XL идёт в качалку / поднимаем контекст до 8k

Отличная работа. На сколько сложно будет добавить поддержку этой модели в Unsloth?

Они недавно выпустили Unsloth Studio, в которой удобный интерфейс для обучения, легче работать с датасетами, благодаря чему в разы проще обучать различные современные модели (Fine-tune, LoRA, QLoRA 4-bit).

Google выпустила Gemma 4 2B/4B/26B/31B: открытые веса и 3-е место на Arena AI

Но не разглядели главное, на контексте в 90к.

Вот типичные 10к, которые покрывают большинство локальных задач:

30.5 t/s

Google выпустила Gemma 4 2B/4B/26B/31B: открытые веса и 3-е место на Arena AI

Проще и быстрее поставить qwen code, в котором есть Qwen3.6-Plus с большими бесплатными лимитами, там 1m контекста, качество в разы лучше и быстрая скорость, а для кого-то всё что хуже Opus 4.6 пустая трата времени.

Для переводить, распознавать картинки, вести диалог и тому подобному очень много контекста не нужно, точнее его нужно сбрасывать, а не накапливать. С помощью cmoe можно высвободить много видеопамяти для других параллельных задач, при этом получить скорость большую, чем выдают LM Studio или ollama. Для агентного использования можно прибегать к субагентам, чтобы не накапливать контекст.

Но вообще, на большом контексте важна скорость PP, чтобы её увеличить, нужно увеличить размер пакетов -ub 3072 -b 3072, или больше. Опционально можно квантовать KV-кэш -ctk q8_0 -ctv q8_0, чтобы снизить расход памяти на контекст в 2 раза. Сейчас тестируют TurboQuant от Google Research, которые заявляют, что можно квантовать контекст до 3.5 бит без заметных потерь, что снизить расход памяти в ~4 раза.

90k контекст, pp 579 t/s, tg 17.4 t/s

90к контекст, подготовка промпта заняла 2.5 минуты, что для агентного программирования хороший результат. Просадка tg не только за счёт контекста, но и ncmoe увеличено с 13 до 22, чтобы вместить столько контекста.

Google выпустила Gemma 4 2B/4B/26B/31B: открытые веса и 3-е место на Arena AI

DDR4 16Gb (2x8gb 3600 Mhz), Ryzen 3600 6 ядер, RTX 3060 12gb, Win10, драйвера nvidia свежие, cuda 13.1.

Gemma-4-26B-A4B-it-Q4_K_M, запуск с -ncmoe 13, генерация 33 t/s:

Qwen3.5-35B-A3B-UD-Q4_K_XL, запуск с -ncmoe 22, генерация 32 t/s:

Подбор оптимального параметра, -ncmoe 18,20,22

Модели не влезают в 12гб VRAM, но если использовать перераспределение MoE тензоров и запускать напрямую llama.cpp, в которой по умолчанию включен параметр -fit, который автоматически подберет оптимальные параметры запуска, или настраивать -ncmoe вручную, то можно получить ощутимую прибавку к скорости по сравнению со стандартным способом ngl, который по умолчанию используется в Ollama и LM Studio.

Google выпустила Gemma 4 2B/4B/26B/31B: открытые веса и 3-е место на Arena AI

4060 Ti 16Gb выдает 65 t/s. Модель именно та, что по умолчанию предлагается в LM Studio:

Gemma-4-26B-A4B, 4060 Ti 16Gb, Win11, -ncmoe 2, 65 t/s

Подробнее, как можно получить больше скорости:

• Запускаем GPT-OSS-120B на 6 Гб GPU и ускоряем до 30 t/s. Вам нужна RAM, а не VRAM. Параметр -cmoe для ускорения MoE LLM

• Запускаем настоящую DeepSeek R1 671B на игровом ПК и смотрим вменяемая ли она на огромном контексте (160к)

Реставрация ruGPT-3 XL или как я вернул к жизни забытую русскую языковую модель

Тут, конечно, это уже надо на нормальном датасете обучать, чтобы заметить разницу. Но архитектура старая, поддержки triton нет, обучение будет в разы дольше, чем дообучить даже, например, Qwen3.5 4B.

Но в целом можно попробовать и так. Сходу при запуске инференса со Sparse Attn ошибка:

cuda\TensorCompare.cu:109: block: [0,0,0], thread: [0,0,0] Assertion `input[0] != 0` failed.
    next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
                  ~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^
torch.AcceleratorError: CUDA error: device-side assert triggered

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

modeling_rugpt3xl.py

"""PyTorch RuGPT-3 XL model.

GPT-3-style decoder-only transformer (1.3B) trained on Russian text.
Architecture: absolute position embeddings, pre-norm layers, GELU activation,
tied LM head.
"""

import math
from typing import List, Optional, Tuple, Union

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.checkpoint

from transformers.activations import ACT2FN
from transformers.cache_utils import Cache, DynamicCache
from transformers.generation import GenerationMixin
from transformers.modeling_outputs import (
    BaseModelOutputWithPast,
    CausalLMOutputWithPast,
)
from transformers.modeling_utils import PreTrainedModel
from transformers.utils import logging

from .configuration_rugpt3xl import RuGPT3XLConfig

logger = logging.get_logger(__name__)


def _make_sparse_layout(
    num_heads: int,
    num_blocks: int,
    num_local_blocks: int,
    num_global_blocks: int,
    num_different_global_patterns: int,
    device: torch.device,
) -> torch.Tensor:
    """Build FixedSparsity boolean layout on *device*.

    Returns [num_heads, num_blocks, num_blocks] bool tensor.
    """
    layout = torch.zeros(
        num_heads, num_blocks, num_blocks, dtype=torch.bool, device=device,
    )

    for win in range(0, num_blocks, num_local_blocks):
        end = min(win + num_local_blocks, num_blocks)
        sz = end - win
        layout[:, win:end, win:end] = torch.tril(
            torch.ones(sz, sz, dtype=torch.bool, device=device)
        )

    for h in range(num_heads):
        first = num_local_blocks - (
            1 + h % num_different_global_patterns
        ) * num_global_blocks
        reg_end = num_blocks - (num_blocks % num_local_blocks)
        for gi in range(first, reg_end, num_local_blocks):
            layout[h, gi:, gi : gi + num_global_blocks] = True
        if reg_end < num_blocks:
            s = min(reg_end + first, num_blocks - num_global_blocks)
            layout[h, s:, s : s + num_global_blocks] = True

    return layout


class RuGPT3XLAttention(nn.Module):
    def __init__(self, config: RuGPT3XLConfig, layer_idx: int):
        super().__init__()
        self.config = config
        self.layer_idx = layer_idx
        self.hidden_size = config.hidden_size
        self.num_heads = config.num_attention_heads
        self.head_dim = self.hidden_size // self.num_heads
        self.scale = self.head_dim ** -0.5

        self.q_proj = nn.Linear(self.hidden_size, self.hidden_size)
        self.k_proj = nn.Linear(self.hidden_size, self.hidden_size)
        self.v_proj = nn.Linear(self.hidden_size, self.hidden_size)
        self.o_proj = nn.Linear(self.hidden_size, self.hidden_size)

        self.attn_dropout = nn.Dropout(config.attention_dropout)
        self.resid_dropout = nn.Dropout(config.output_dropout)

    def forward(
        self,
        hidden_states: torch.Tensor,
        attention_mask: Optional[torch.Tensor] = None,
        position_ids: Optional[torch.LongTensor] = None,
        past_key_value: Optional[Cache] = None,
        output_attentions: bool = False,
        use_cache: bool = False,
        **kwargs,
    ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Cache]]:
        bsz, q_len, _ = hidden_states.size()

        query = self.q_proj(hidden_states)
        key = self.k_proj(hidden_states)
        value = self.v_proj(hidden_states)

        query = query.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
        key = key.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)
        value = value.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)

        if past_key_value is not None:
            key, value = past_key_value.update(key, value, self.layer_idx)

        attn_weights = torch.matmul(query, key.transpose(2, 3)) * self.scale

        if attention_mask is not None:
            attn_weights = attn_weights + attention_mask

        attn_weights = F.softmax(attn_weights, dim=-1, dtype=torch.float32).to(
            query.dtype
        )
        attn_weights = self.attn_dropout(attn_weights)

        attn_output = torch.matmul(attn_weights, value)
        attn_output = attn_output.transpose(1, 2).contiguous()
        attn_output = attn_output.reshape(bsz, q_len, self.hidden_size)

        attn_output = self.o_proj(attn_output)
        attn_output = self.resid_dropout(attn_output)

        return (
            attn_output,
            attn_weights if output_attentions else None,
            past_key_value,
        )


class RuGPT3XMLP(nn.Module):
    def __init__(self, config: RuGPT3XLConfig):
        super().__init__()
        self.up_proj = nn.Linear(config.hidden_size, config.intermediate_size)
        self.down_proj = nn.Linear(config.intermediate_size, config.hidden_size)
        self.act_fn = ACT2FN[config.hidden_act]
        self.dropout = nn.Dropout(config.output_dropout)

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        return self.dropout(self.down_proj(self.act_fn(self.up_proj(hidden_states))))


class RuGPT3XLDecoderLayer(nn.Module):
    def __init__(self, config: RuGPT3XLConfig, layer_idx: int):
        super().__init__()
        self.input_layernorm = nn.LayerNorm(
            config.hidden_size, eps=config.layer_norm_eps
        )
        self.self_attn = RuGPT3XLAttention(config, layer_idx)
        self.post_attention_layernorm = nn.LayerNorm(
            config.hidden_size, eps=config.layer_norm_eps
        )
        self.mlp = RuGPT3XMLP(config)

    def forward(
        self,
        hidden_states: torch.Tensor,
        attention_mask: Optional[torch.Tensor] = None,
        position_ids: Optional[torch.LongTensor] = None,
        past_key_value: Optional[Cache] = None,
        output_attentions: bool = False,
        use_cache: bool = False,
        **kwargs,
    ) -> Tuple[torch.Tensor, ...]:
        residual = hidden_states
        hidden_states = self.input_layernorm(hidden_states)
        hidden_states, self_attn_weights, present_key_value = self.self_attn(
            hidden_states=hidden_states,
            attention_mask=attention_mask,
            position_ids=position_ids,
            past_key_value=past_key_value,
            output_attentions=output_attentions,
            use_cache=use_cache,
            **kwargs,
        )
        hidden_states = residual + hidden_states

        residual = hidden_states
        hidden_states = self.post_attention_layernorm(hidden_states)
        hidden_states = self.mlp(hidden_states)
        hidden_states = residual + hidden_states

        outputs = (hidden_states,)
        if output_attentions:
            outputs += (self_attn_weights,)
        if use_cache:
            outputs += (present_key_value,)
        return outputs


class RuGPT3XLPreTrainedModel(PreTrainedModel):
    config_class = RuGPT3XLConfig
    base_model_prefix = "model"
    supports_gradient_checkpointing = True
    _no_split_modules = ["RuGPT3XLDecoderLayer"]
    _skip_keys_device_placement = ["past_key_values"]
    _supports_cache_class = True

    def _init_weights(self, module):
        std = self.config.initializer_range
        if isinstance(module, nn.Linear):
            module.weight.data.normal_(mean=0.0, std=std)
            if module.bias is not None:
                module.bias.data.zero_()
        elif isinstance(module, nn.Embedding):
            module.weight.data.normal_(mean=0.0, std=std)
            if module.padding_idx is not None:
                module.weight.data[module.padding_idx].zero_()
        elif isinstance(module, nn.LayerNorm):
            module.bias.data.zero_()
            module.weight.data.fill_(1.0)


class RuGPT3XLModel(RuGPT3XLPreTrainedModel):
    """Bare RuGPT-3 XL transformer outputting raw hidden states."""

    def __init__(self, config: RuGPT3XLConfig):
        super().__init__(config)
        self.padding_idx = config.pad_token_id
        self.vocab_size = config.vocab_size

        self.embed_tokens = nn.Embedding(
            config.vocab_size, config.hidden_size, self.padding_idx
        )
        self.embed_positions = nn.Embedding(
            config.max_position_embeddings, config.hidden_size
        )
        self.embed_dropout = nn.Dropout(config.embedding_dropout)

        self.layers = nn.ModuleList(
            [
                RuGPT3XLDecoderLayer(config, layer_idx)
                for layer_idx in range(config.num_hidden_layers)
            ]
        )
        self.norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)

        # Sparse attention config
        self._sparse_layers: set = set()
        if getattr(config, "sparse_mode", "none") == "alternating":
            self._sparse_layers = {
                i for i in range(config.num_hidden_layers) if i % 2 == 0
            }
        elif getattr(config, "sparse_mode", "none") == "all":
            self._sparse_layers = set(range(config.num_hidden_layers))

        # Sparse layout will be lazily built on first forward.
        # NOT registered as a buffer to avoid meta-device corruption.
        self._sparse_layout: Optional[torch.Tensor] = None

        self.gradient_checkpointing = False
        self.post_init()

    def _get_sparse_layout(self, device: torch.device) -> torch.Tensor:
        """Return sparse layout tensor on *device*, building it if necessary."""
        if self._sparse_layout is not None and self._sparse_layout.device == device:
            return self._sparse_layout

        cfg = self.config
        num_blocks = cfg.max_position_embeddings // cfg.sparse_block_size
        self._sparse_layout = _make_sparse_layout(
            num_heads=cfg.num_attention_heads,
            num_blocks=num_blocks,
            num_local_blocks=cfg.sparse_num_local_blocks,
            num_global_blocks=cfg.sparse_num_global_blocks,
            num_different_global_patterns=cfg.sparse_num_different_global_patterns,
            device=device,
        )
        return self._sparse_layout

    def get_input_embeddings(self):
        return self.embed_tokens

    def set_input_embeddings(self, value):
        self.embed_tokens = value

    def forward(
        self,
        input_ids: Optional[torch.LongTensor] = None,
        attention_mask: Optional[torch.Tensor] = None,
        position_ids: Optional[torch.LongTensor] = None,
        past_key_values: Optional[Union[Cache, List[torch.FloatTensor]]] = None,
        inputs_embeds: Optional[torch.FloatTensor] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
        **kwargs,
    ) -> Union[Tuple, BaseModelOutputWithPast]:
        output_attentions = (
            output_attentions
            if output_attentions is not None
            else self.config.output_attentions
        )
        output_hidden_states = (
            output_hidden_states
            if output_hidden_states is not None
            else self.config.output_hidden_states
        )
        use_cache = use_cache if use_cache is not None else self.config.use_cache
        return_dict = (
            return_dict if return_dict is not None else self.config.use_return_dict
        )

        if input_ids is not None and inputs_embeds is not None:
            raise ValueError(
                "You cannot specify both input_ids and inputs_embeds"
            )
        if input_ids is not None:
            batch_size, seq_length = input_ids.shape[:2]
        elif inputs_embeds is not None:
            batch_size, seq_length = inputs_embeds.shape[:2]
        else:
            raise ValueError(
                "You have to specify either input_ids or inputs_embeds"
            )

        if self.gradient_checkpointing and self.training and use_cache:
            logger.warning_once(
                "`use_cache=True` is incompatible with gradient checkpointing. "
                "Setting `use_cache=False`."
            )
            use_cache = False

        past_key_values_length = 0
        if use_cache:
            if past_key_values is None:
                past_key_values = DynamicCache()
            past_key_values_length = past_key_values.get_seq_length()

        if position_ids is None:
            device = (
                input_ids.device if input_ids is not None else inputs_embeds.device
            )
            position_ids = torch.arange(
                past_key_values_length,
                seq_length + past_key_values_length,
                dtype=torch.long,
                device=device,
            ).unsqueeze(0)

        if inputs_embeds is None:
            inputs_embeds = self.embed_tokens(input_ids)

        position_embeds = self.embed_positions(position_ids)
        hidden_states = self.embed_dropout(inputs_embeds + position_embeds)

        # Dense causal mask
        causal_mask = self._build_causal_mask(
            batch_size,
            seq_length,
            past_key_values_length,
            hidden_states.dtype,
            hidden_states.device,
            attention_mask,
        )

        # Sparse causal mask (lazily build layout on correct device)
        sparse_mask = None
        if self._sparse_layers:
            sparse_layout = self._get_sparse_layout(hidden_states.device)
            sparse_mask = self._build_sparse_causal_mask(
                seq_length,
                past_key_values_length,
                hidden_states.dtype,
                hidden_states.device,
                sparse_layout,
                self.config.sparse_block_size,
                attention_mask,
            )

        all_hidden_states = () if output_hidden_states else None
        all_self_attns = () if output_attentions else None
        next_decoder_cache = None

        for layer_idx, decoder_layer in enumerate(self.layers):
            if output_hidden_states:
                all_hidden_states += (hidden_states,)

            layer_mask = (
                sparse_mask
                if (layer_idx in self._sparse_layers and sparse_mask is not None)
                else causal_mask
            )

            if self.gradient_checkpointing and self.training:
                layer_outputs = self._gradient_checkpointing_func(
                    decoder_layer.__call__,
                    hidden_states,
                    layer_mask,
                    position_ids,
                    past_key_values,
                    output_attentions,
                    use_cache,
                )
            else:
                layer_outputs = decoder_layer(
                    hidden_states,
                    attention_mask=layer_mask,
                    position_ids=position_ids,
                    past_key_value=past_key_values,
                    output_attentions=output_attentions,
                    use_cache=use_cache,
                )

            hidden_states = layer_outputs[0]
            if use_cache:
                next_decoder_cache = layer_outputs[
                    2 if output_attentions else 1
                ]
            if output_attentions:
                all_self_attns += (layer_outputs[1],)

        hidden_states = self.norm(hidden_states)

        if output_hidden_states:
            all_hidden_states += (hidden_states,)

        next_cache = next_decoder_cache if use_cache else None

        if not return_dict:
            return tuple(
                v
                for v in [
                    hidden_states,
                    next_cache,
                    all_hidden_states,
                    all_self_attns,
                ]
                if v is not None
            )
        return BaseModelOutputWithPast(
            last_hidden_state=hidden_states,
            past_key_values=next_cache,
            hidden_states=all_hidden_states,
            attentions=all_self_attns,
        )

    @staticmethod
    def _build_causal_mask(
        batch_size: int,
        seq_length: int,
        past_length: int,
        dtype: torch.dtype,
        device: torch.device,
        attention_mask: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        total_length = past_length + seq_length
        causal = torch.full(
            (seq_length, total_length),
            torch.finfo(dtype).min,
            device=device,
        )
        causal = causal.masked_fill(
            torch.arange(total_length, device=device).unsqueeze(0)
            <= torch.arange(
                past_length, past_length + seq_length, device=device
            ).unsqueeze(1),
            0.0,
        )
        causal = causal.unsqueeze(0).unsqueeze(0)

        if attention_mask is not None:
            pad_mask = (
                (1 - attention_mask[:, None, None, :].to(dtype))
                * torch.finfo(dtype).min
            )
            causal = causal + pad_mask

        return causal

    @staticmethod
    def _build_sparse_causal_mask(
        seq_length: int,
        past_length: int,
        dtype: torch.dtype,
        device: torch.device,
        sparse_layout: torch.Tensor,
        block_size: int,
        attention_mask: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        total_length = past_length + seq_length
        num_blocks = sparse_layout.shape[1]

        q_block = (
            torch.arange(past_length, past_length + seq_length, device=device)
            // block_size
        ).clamp(max=num_blocks - 1)
        k_block = (
            torch.arange(total_length, device=device) // block_size
        ).clamp(max=num_blocks - 1)

        block_ok = sparse_layout[:, q_block][:, :, k_block]

        q_pos = torch.arange(
            past_length, past_length + seq_length, device=device
        ).unsqueeze(1)
        k_pos = torch.arange(total_length, device=device).unsqueeze(0)
        causal_ok = k_pos <= q_pos

        allowed = block_ok & causal_ok.unsqueeze(0)

        min_val = torch.finfo(dtype).min
        mask = torch.where(allowed, 0.0, min_val).to(dtype).unsqueeze(0)

        if attention_mask is not None:
            pad_mask = (
                (1 - attention_mask[:, None, None, :].to(dtype)) * min_val
            )
            mask = mask + pad_mask

        return mask


class RuGPT3XLForCausalLM(RuGPT3XLPreTrainedModel, GenerationMixin):
    _tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}
    _supports_cache_class = True

    def __init__(self, config: RuGPT3XLConfig):
        super().__init__(config)
        self.model = RuGPT3XLModel(config)
        self.vocab_size = config.vocab_size
        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
        self.post_init()

    def get_input_embeddings(self):
        return self.model.embed_tokens

    def set_input_embeddings(self, value):
        self.model.embed_tokens = value

    def get_output_embeddings(self):
        return self.lm_head

    def set_output_embeddings(self, new_embeddings):
        self.lm_head = new_embeddings

    def get_decoder(self):
        return self.model

    def set_decoder(self, decoder):
        self.model = decoder

    def forward(
        self,
        input_ids: Optional[torch.LongTensor] = None,
        attention_mask: Optional[torch.Tensor] = None,
        position_ids: Optional[torch.LongTensor] = None,
        past_key_values: Optional[Union[Cache, List[torch.FloatTensor]]] = None,
        inputs_embeds: Optional[torch.FloatTensor] = None,
        labels: Optional[torch.LongTensor] = None,
        use_cache: Optional[bool] = None,
        output_attentions: Optional[bool] = None,
        output_hidden_states: Optional[bool] = None,
        return_dict: Optional[bool] = None,
        **kwargs,
    ) -> Union[Tuple, CausalLMOutputWithPast]:
        output_attentions = (
            output_attentions
            if output_attentions is not None
            else self.config.output_attentions
        )
        output_hidden_states = (
            output_hidden_states
            if output_hidden_states is not None
            else self.config.output_hidden_states
        )
        return_dict = (
            return_dict if return_dict is not None else self.config.use_return_dict
        )

        outputs = self.model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            position_ids=position_ids,
            past_key_values=past_key_values,
            inputs_embeds=inputs_embeds,
            use_cache=use_cache,
            output_attentions=output_attentions,
            output_hidden_states=output_hidden_states,
            return_dict=return_dict,
        )

        hidden_states = outputs[0]
        logits = self.lm_head(hidden_states).float()

        loss = None
        if labels is not None:
            shift_logits = logits[..., :-1, :].contiguous()
            shift_labels = labels[..., 1:].contiguous()
            loss_fct = nn.CrossEntropyLoss()
            shift_logits = shift_logits.view(-1, self.config.vocab_size)
            shift_labels = shift_labels.view(-1).to(shift_logits.device)
            loss = loss_fct(shift_logits, shift_labels)

        if not return_dict:
            output = (logits,) + outputs[1:]
            return (loss,) + output if loss is not None else output

        return CausalLMOutputWithPast(
            loss=loss,
            logits=logits,
            past_key_values=outputs.past_key_values,
            hidden_states=outputs.hidden_states,
            attentions=outputs.attentions,
        )

    def prepare_inputs_for_generation(
        self,
        input_ids,
        past_key_values=None,
        attention_mask=None,
        inputs_embeds=None,
        **kwargs,
    ):
        if past_key_values is not None:
            past_length = past_key_values.get_seq_length()
            if (
                attention_mask is not None
                and attention_mask.shape[1] > input_ids.shape[1]
            ):
                input_ids = input_ids[
                    :, -(attention_mask.shape[1] - past_length) :
                ]
            elif past_length < input_ids.shape[1]:
                input_ids = input_ids[:, past_length:]

        position_ids = kwargs.get("position_ids", None)
        if attention_mask is not None and position_ids is None:
            position_ids = attention_mask.long().cumsum(-1) - 1
            position_ids.masked_fill_(attention_mask == 0, 1)
        if position_ids is not None and past_key_values is not None:
            position_ids = position_ids[:, -input_ids.shape[1] :]

        if inputs_embeds is not None and past_key_values is None:
            model_inputs = {"inputs_embeds": inputs_embeds}
        else:
            model_inputs = {"input_ids": input_ids}

        model_inputs.update(
            {
                "position_ids": position_ids,
                "past_key_values": past_key_values,
                "use_cache": kwargs.get("use_cache"),
                "attention_mask": attention_mask,
            }
        )
        return model_inputs

Теперь запускается нормально и можно обучить, и чтобы проверить работает ли вообще отсечение, в forward можно добавить отладочную информацию:

Добавить в forward

        next_decoder_cache = None

        # === start debug ===
        if seq_length > 1 and sparse_mask is not None:
            total_len = seq_length + past_key_values_length
            
            min_val_dense = torch.finfo(causal_mask.dtype).min
            min_val_sparse = torch.finfo(sparse_mask.dtype).min
            
            q_dim = causal_mask.shape[-2]
            k_dim = causal_mask.shape[-1]
            total_elements = q_dim * k_dim
            
            num_matrices_dense = causal_mask.numel() // total_elements
            num_matrices_sparse = sparse_mask.numel() // total_elements
            
            dense_blocked = int((causal_mask == min_val_dense).sum().item() / num_matrices_dense)
            sparse_blocked = int((sparse_mask == min_val_sparse).sum().item() / num_matrices_sparse)
            extra_blocked = sparse_blocked - dense_blocked
            
            allowed_in_dense = total_elements - dense_blocked
            sparse_penalty_pct = (extra_blocked / allowed_in_dense) * 100 if allowed_in_dense > 0 else 0.0

            print(f"\n[SPARSE DEBUG] seq_len={seq_length}, total_len={total_len}")
            print(f"Каузальная маска (Dense): shape={tuple(causal_mask.shape)}, blocked={dense_blocked}/{total_elements} ({(dense_blocked/total_elements)*100:.1f}%)")
            print(f"Разреженная маска (Sparse): shape={tuple(sparse_mask.shape)}, blocked={sparse_blocked}/{total_elements} ({(sparse_blocked/total_elements)*100:.1f}%)")
            print(f"Уровень разреженности (Sparse): +{sparse_penalty_pct:.1f}% (отсечено {extra_blocked} связей)")
        # === end debug === 

        for layer_idx, decoder_layer in enumerate(self.layers):

Так как Sparse Attn тут настроен на 128 токенов, то если запрос меньше, то Sparse должна быть равна Dense и фактически не работать:

Запрос длиннее 128, тут Sparse успешно отсекает и с виду нормально работает:

Попробовал обучить LoRA на первом попавшемся датасете диалогов Den4ikAI/russian_dialogues, датасет на 2.5 млн строк или 40m токенов. Обучил только на первых 10000 за 5-10 минут.

Обучилась успешно, и приобрела особый стиль общения, который присутствовал в датасете:

Датасет, наверное, не очень удачный, но это хороший пример, что если есть base, то из базы можно выровнять (alignment) модель до различных состояний.

Реставрация ruGPT-3 XL или как я вернул к жизни забытую русскую языковую модель

Вы пытаетесь работать с base моделью как с instruct моделью.

Base (или pretrain) - это 1 шаг обучения LLM из 3. Смысл pretrain в том, чтобы модель умела составлять буквы в слова, слова в предложения, предложения были орфографически верные, логически правильные, набирала базу знаний и так далее. Такая нейросеть умеет продолжать текст, вы пишите ей “cat = кошка, dog = собака, duck =” и она продолжает “утка”.

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

"<|im_start|>user\n{question}<|im_end|>\n<|im_start|>assistant\n{answer}<|im_end|>"

Поэтому базовая модель в таком сценарии начинает генерировать хаотичные ответы. Чтобы base научилась нормально вести диалог, нужно обучить её шаблону.

Для примера, обучим эту ruGPT3 XL base до уровня instruct (до очень примитивного, так как датасет должен быть куда разнообразнее). Генерируем 100 пар вопрос-ответ такого вида:

Теперь из этих пар нужно создать датасет согласно шаблону-чата модели, в данном случае это:

Вопрос: ...
Ответ: ...

Обучаем нейросеть как finetune целиком или как LoRA адаптер. Для примера хватит 3 эпох на 100 примерах:

Через пару минут “ruGPT3XL-instruct” готова. Теперь можно задать какой-нибудь вопрос, которого не было в дополнительном датасете:

Кто такой Шекспир?

Ты знаешь что-то про Fallout?

Мы не учили модель отвечать, кто такой Шекспир, и не учили её ничему про Fallout, это уже было в модели. Мы только научили её обрабатывать шаблон чата, и, побочно, структуре ответа как из энциклопедии. Аналогично её можно научить агентным задачам и так далее.

Ну, LLM, погоди…

Только просто выделения контекста недостаточно, нужно его еще заполнить на 100%

Да нет, память целиком выделяет в момент загрузки. Заполненность влияет только на скорость генерации.

GPT-OSS-20B для контекста использует SWA, механизм который в разы снижает потребление VRAM, чтобы его активировать, нужно включить Flash Attention. Полные 128к требуют +6гб VRAM, если включить квантование KV-кэша Q8_0, то будет +3Гб.

В llama.cpp по умолчанию работает новый режим --fit, который автоматически подбирает оптимальные параметры для эффективного использования GPU минус 1гб VRAM (параметр настраивается) и включает flash attention, поэтому такое отличие от LM Studio.

Под эффективным имеется ввиду другое распределение тензоров, те, которые используются всегда, пойдут на GPU, остальные, которые используются периодически, на CPU, и если осталась VRAM, то будет заполнена разреженными слоями с экспертами. Почему это так работает, выше я уже кидал ссылку на статью Вам нужна RAM, а не VRAM, где это объясняется.

В LM Studio можно включить "половину" от этого режима галочкой Force Model Expert Weights onto CPU (во время выбора модели зажать Alt для расширенных настроек), и перепроверить, что включен Flash Attention, чтобы оптимизировать расход памяти под контекст.

Ну, LLM, погоди…

Модель для сложных задач и длинных ответов: mlx-community/Qwen2.5-72B-Instruct-4bit (~12 токен/с).

Qwen2.5 устарела на ~1.5 года, даже Qwen3 уже не особо актуальна. Переходите на новые более качественные модели, ваша машина легко потянет современные хорошие MoE-модели, которые в разы быстрее чем Qwen2.5-72B и, что важнее, намного качественнее.

Из современных моделей к 128Гб подойдут: OpenAI GPT-OSS-120B, GLM-4.5-Air 110B, Minimax M2.1 229B (в динамическом квантовании UD gguf, mlx не влезет в 128гб). Малые версии тоже есть, например, Qwen3-30B-A3B-2507 и остальные из современного списка, при этом с того момента успели выйти хорошие новинки.

Динамическое квантование от Unsloth позволяет опустится ниже 4-бит квантования, при этом сохраняя достаточно хорошее качество, так что можно запустить и Qwen3-235B-A22B, и свежий Minimax M2.1 229B.

Бенчмарк программирования Aider Polyglot для 1, 2, 3-битного динамического квантования UD:

UD-Q3_K_XL почти не отличается от оригинала, UD-Q2_K_XL хуже на 13%, UD-Q1_K_XL хуже на 30%

Ноутбук у меня вполне бодрый (i9, 64 GB RAM, RTX 4070)
Идея была простая: докупить eGPU (а лучше - несколько) и получить относительно мощный сетап без покупки отдельной рабочей станции

Вообще, этот ноутбук позволяет запускать на хорошей скорости GPT-OSS-120B или GLM-4.5-Air и без eGPU, 64Гб RAM хватит, а через 4070 будет приличное ускорение для MoE.

Подробнее как запускать такое на ноутбуке или ПК где достаточно RAM и есть немного VRAM:
Запускаем GPT-OSS-120B на 6 Гб GPU и ускоряем до 30 t/s. Вам нужна RAM, а не VRAM.

Лоботомия нейросети: удалил 7 слоёв из LLM — она стала на 30% быстрее

Cerebras осенью представили метод REAP для вырезания "лишних" экспертов из MoE уменьшая размер модели до 50%, по их словам почти без потерь в области программирования и tool-calling: https://arxiv.org/abs/2510.13999

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

На huggingface много моделей в REAP виде уже готовы: https://huggingface.co/models?search=reap

Модель ИИ-перевода Hunyuan HY-MT1.5-1.8B возглавила рейтинг на Hugging Face

Спасибо за замеры, обычно это называют benchmaxxing. Вот тут у человека, делающего llm-translate, схожий отзыв: https://habr.com/ru/articles/951416/comments/#comment_28935346

Есть еще tencent/Hunyuan-MT-7B. Тестировали?

Попробовал, ситуация интересная. Мне перевод показался плохим - в каких-то местах выдуманные куски, модель путает "вы-ты", странные конструкции. Но при этом формальная оценка - 91,33, выше, чем у любой другой модели. Добавил результаты в гугл-таблицу, ссылка на которую приведена в статье.

СМИ: Nvidia планирует перезапустить GeForce RTX 3060 в начале 2026 года, чтобы решить проблему нехватки GPU и ОЗУ

Phi-2 (2.7B), Mistral-7B, Llama-3-8B, Gemma-7B

Перечисленные не очень свежие, Mistral-7B и вовсе 2023 года, одна из самых-самых первых, давно вышли более качественнее модели, если брать в том же размере, то это Ministral-3-8B-Instruct-2512, у Phi вышла Phi-4, Gemma выпустила Gemma3, а вместо Llama3 - Qwen3.

Модели, которые можно запустить на GTX 3060 (12 ГБ)

С недавних пор на 3060 можно запустить и вполне себе большие модели, и с нормальной скоростью. Только нужна ОЗУ и можно ускорять MoE модели с помощью одной GPU.

Если стандартные 16Гб RAM, то можно запускать Qwen3-30B-A3B (включая Vision), Granite-4.0-H-Small 32B, GPT-OSS-20B. Если есть 64Гб, то можно запускать, например, GPT-OSS-120B или GLM-4.5-Air, на 96Гб можно запускать новую MiniMax-M2.1 230B, а на 192Гб DDR5 уже можно запустить DeepSeek R1 671B и V3.1.

Вот, например, на медленной AMD RX 6600 (скорость памяти 224 ГБ/с, а у 3060 скорость 360 ГБ/с, скорость LLM напрямую зависит от скорости памяти), модель GPT-OSS-120B выдает 13 t/s:

GPT-OSS-120B, AMD RX 6600 8Гб + Ryzen 5600g 64Гб DDR4-3600, Windows 11, 13 t/s

Ваш ноутбук пока не готов к LLM, но скоро это изменится

а по скорости все равно выигрывают nvidia видеокарты, причем даже не самые свежие.
новейший ryzen ai max используется в gpd win 5. Вы на полном серьезе считаете, что в карманной приставке будет какая-то мощь, способная потянуть ИИ? Ну загрузите вы какую-нибудь большую модель в 128гб, а дальше что? Отдача 1-2 токена в секунду?

Размер устройства не имеет значения, имеет значение количество каналов памяти и тип памяти.

Скорость генерации LLM линейно зависит от скорости памяти, в GPU используют быструю GDDR6X и DDR7 и широкую шину памяти, получая скорость 1 Тб/c на 4090. В Ryzen AI Max+ 365, как и в NVIDIA DGX Spark, используется DDR5 и всего 4 канала памяти, скорость памяти 256 Гб/с. Для сравнения у 4060ti всего 288 Гб/с, что немногим больше.

Смотря на какой архитектуре модель: Dense или MoE. Новый Devstral 2 123B сделан как Dense, там будет 3 t/s, но многие переходят на MoE, поэтому там будет скорость намного выше.

Ryzen AI Max+ выдает 50 t/s на GPT-OSS-120B, это очень комфортная скорость для работы, и на 128Гб можно запустить более качественные модели, вроде GLM-4.5-Air или MiniMax-M2.1 230B, скорость будет в районе 25-30 t/s.

Подробнее про MoE модели: Запускаем GPT-OSS-120B на 6 Гб GPU и ускоряем до 30 t/s. Вам нужна RAM, а не VRAM. Параметр -cmoe для ускорения MoE LLM