AIKraft Agents
Главная/Блог/Аналитика/TorchNeuron: Запуск моделей Hugging…
Аналитика9 мин чтения · 20 октября 2026 г.

TorchNeuron: Запуск моделей Hugging Face на AWS Trainium без компромиссов

TorchNeuron — это новый нативный бэкенд для PyTorch на AWS Trainium, который устраняет необходимость в сложных обходных путях и позволяет запускать модели Hugging Face так же просто, как на GPU.

TorchNeuron: Запуск моделей Hugging Face на AWS Trainium без компромиссов

Долгие годы экосистема Hugging Face и облачные ускорители AWS развивались параллельно, но с заметным разрывом в удобстве. Если вы когда-либо пытались запустить современную модель трансформера или диффузионную модель на чипах AWS Trainium или Inferentia, вы, вероятно, сталкивались с определенным уровнем трения. Традиционный подход, реализованный через библиотеку optimum-neuron, требовал от разработчика мыслить как компилятор: использовать ленивые тензоры (lazy tensors), фиксированные размеры входных данных и постоянно перекомпилировать графы вычислений при малейшем изменении структуры. Это создавало барьер для входа, заставляя исследователей и инженеров тратить время не на эксперименты с моделями, а на борьбу с инфраструктурными особенностями.

Ситуация кардинально меняется с выходом TorchNeuron. Это не просто еще одна библиотека-обертка, а полноценный плагин для PyTorch, который интегрирует архитектуру AWS Trainium непосредственно в ядро фреймворка. Теперь Trainium становится «родным» устройством, таким же, как NVIDIA GPU или Google TPU. Разработчики получают доступ к режиму выполнения eager (немедленное выполнение), нативным распределенным API PyTorch, таким как FSDP (Fully Sharded Data Parallel) и TP (Tensor Parallelism), а также к мощи torch.compile. В этой статье мы подробно разберем, как TorchNeuron меняет правила игры, какие возможности он открывает для инференса и обучения, и как начать использовать эти технологии уже сегодня.

01От Optimum Neuron к TorchNeuron: Эволюция подхода

Чтобы понять масштаб изменений, важно回顾 (вспомнить) контекст. До недавнего времени основным способом работы с нейронными процессорами AWS в экосистеме Hugging Face была библиотека optimum-neuron. Она строилась на базе пакета torch-neuronx, который, в свою очередь, опирался на PyTorch XLA. Архитектура XLA (Accelerated Linear Algebra) исторически ориентирована на компиляцию вычислительных графов. Это означает, что вместо того чтобы выполнять операции по мере их вызова (как в стандартном PyTorch), система сначала собирает весь граф вычислений, оптимизирует его и только затем запускает на устройстве.

Хотя такой подход обеспечивает высокую эффективность при инференсе, он накладывает строгие ограничения:

  • Ленивые тензоры (Lazy Tensors): Операции не выполняются сразу, что усложняет отладку и использование стандартных инструментов профилирования.
  • Статические формы (Static Shapes): Размеры входных тензоров должны быть известны заранее. Изменение длины последовательности или размера батча часто требовало полной перекомпиляции графа, что крайне затратно по времени.
  • Разрывы графов (Graph Breaks): Любая динамическая логика в коде (например, условные операторы, зависящие от данных) могла привести к «разрыву» графа, заставляя XLA откатываться к медленному выполнению или требовать перекомпиляции.

Библиотека optimum-neuron пыталась скрыть эту сложность, предоставляя собственные классы моделей и тренера, но это создавало дублирование кода и изоляцию от основного развития PyTorch. TorchNeuron решает эту проблему, интегрируя бэкенд neuron напрямую в PyTorch. Теперь вы можете использовать стандартные классы transformers, diffusers, accelerate, peft и trl без необходимости писать специфичный для Neuron код. Это парадигмальный сдвиг: железо становится прозрачным для разработчика.

TorchNeuron: Запуск моделей Hugging Face на AWS Trainium без компромиссов

02Инференс: Поддержка текстовых и визуальных моделей

Одним из самых значимых преимуществ TorchNeuron является резкое расширение поддержки моделей в библиотеке transformers. Если раньше с помощью Optimum Neuron можно было запустить около 46% из 100 самых популярных архитектур для генерации текста, то с TorchNeuron этот показатель вырос до 89%. Это означает, что большинство современных LLM (Large Language Models) теперь работают «из коробки».

Генерация текста с тензорным параллелизмом

Для эффективной работы с большими моделями на Trainium критически важно использовать тензорный параллелизм (Tensor Parallelism, TP). Он позволяет разделить веса модели между несколькими NeuronCores, что значительно ускоряет инференс. В TorchNeuron это реализуется нативно через API PyTorch.

Рассмотрим пример кода для генерации текста с использованием модели Qwen3.8-27B. Обратите внимание на ключевые моменты:

TorchNeuron: Запуск моделей Hugging Face на AWS Trainium без компромиссов
terminalpython
import os
import torch
import torch.distributed as dist
import torch_neuronx  # noqa: F401
from torch.distributed import DeviceMesh
from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
from transformers.distributed import DistributedConfig
from transformers.generation.configuration_utils import CompileConfig

MODEL_ID = "Qwen/Qwen3.8-27B"
MAX_SEQ_LEN = 1024
PREFILL_CHUNK_SIZE = 512

dist.init_process_group(backend="neuron", world_size=dist.get_world_size())

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype=torch.bfloat16,
    distributed_config=DistributedConfig(tp_size=world_size),
    device_mesh=DeviceMesh("neuron", list(range(world_size))),
).eval()

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "left"

inputs = tokenizer.apply_chat_template(
    [{"role": "user", "content": "The future of AI is"}],
    add_generation_prompt=True,
    padding=True,
    tokenizer_kwargs={"pad_to_multiple_of": PREFILL_CHUNK_SIZE},
    return_tensors="pt"
)

generation_config = GenerationConfig(
    max_new_tokens=128,
    do_sample=False,
    use_cache=True,
    pad_token_id=tokenizer.pad_token_id,
    eos_token_id=tokenizer.eos_token_id,
    cache_implementation="static",
    max_cache_len=MAX_SEQ_LEN,
    prefill_chunk_size=PREFILL_CHUNK_SIZE,
    compile_config=CompileConfig(backend="neuron", fullgraph=False, dynamic=False),
)

with torch.no_grad():
    output_ids = model.generate(
        inputs["input_ids"],
        attention_mask=inputs["attention_mask"],
        generation_config=generation_config,
    )

if dist.get_rank() == 0:
    prompt_len = inputs["input_ids"].shape[1]
    print(tokenizer.decode(output_ids[0, prompt_len:], skip_special_tokens=True))

В этом примере важно отметить использование cache_implementation="static". На устройствах Neuron статический кэш настоятельно рекомендуется для предотвращения частых перекомпиляций во время генерации. Параметр compile_config явно указывает бэкенду использовать оптимизации Neuron, отключая динамические формы для повышения производительности.

Генерация изображений с Diffusers

Библиотека diffusers также получила полноценную поддержку. Теперь вы можете запускать такие модели, как FLUX.1-dev, FLUX.2, Qwen-Image и H3, используя тензорный параллелизм. Это особенно актуально для больших диффузионных моделей, которые требуют значительных вычислительных ресурсов.

Пример ниже демонстрирует инициализацию пайплайна Qwen-Image-2.1 с распределением модели по 8 NeuronCores:

terminalpython
import torch, torch.distributed as dist, torch_neuronx
from torch.distributed.device_mesh import DeviceMesh
from diffusers import QwenImage21Pipeline, QwenImage21Transformer2DModel, TensorParallelConfig

dist.init_process_group(backend="neuron")
dev = torch.neuron.current_device()
mesh = DeviceMesh("neuron", list(range(8)))  # TP=8

model = "Qwen/Qwen-Image-2.1"
transformer = QwenImage21Transformer2DModel.from_pretrained(
    model,
    subfolder="transformer",
    torch_dtype=torch.bfloat16,
    parallel_config=TensorParallelConfig(mesh=mesh),
)

pipe = QwenImage21Pipeline.from_pretrained(
    model,
    transformer=transformer,
    torch_dtype=torch.bfloat16,
)
pipe.vae.to(dev)
pipe.transformer.compile_repeated_blocks(backend="neuron", fullgraph=True, dynamic=False)

emb, mask, _ = pipe.encode_prompt(prompt="A capybara wearing a wizard hat, oil painting", device="cpu")

image = pipe(
    prompt_embeds=emb.to(dev),
    prompt_embeds_mask=mask.to(dev) if mask is not None else None,
    height=1024,
    width=1024,
    num_inference_steps=40,
    generator=torch.Generator("cpu").manual_seed(42),
).images[0]

if dist.get_rank() == 0:
    image.save("out.png")

Запуск такого кода осуществляется через torchrun, где переменная окружения NEURON_LOGICAL_NC_CONFIG=2 настраивает логическую конфигурацию ядер. Важно, что текстовый энкодер в этом примере остается на CPU, а вычислительная нагрузка по генерации изображения распределяется по NeuronCores.

TorchNeuron: Запуск моделей Hugging Face на AWS Trainium без компромиссов

03Обучение: Нативная интеграция с TRL и Accelerate

Самое революционное изменение касается обучения (training). Раньше для тонкой настройки моделей на Trainium требовались специализированные форки кода или сложные скрипты. С TorchNeuron процесс обучения становится идентичным обучению на GPU. Вы можете использовать стандартные библиотеки transformers, accelerate, peft и trl (Transformer Reinforcement Learning).

Пример SFT-обучения с TRL

Рассмотрим скрипт для Supervised Fine-Tuning (SFT) с использованием SFTTrainer из библиотеки TRL. Код выглядит так же, как и для GPU, за исключением нескольких специфичных настроек для Neuron:

terminalpython
import os
import torch
from datasets import load_dataset
from transformers.distributed import DistributedConfig
from trl import ModelConfig, ScriptArguments, SFTConfig, SFTTrainer, TrlParser

def main(script_args, training_args, model_args):
    # Neuron backend пока не поддерживает автоматические динамические формы Dynamo
    torch._dynamo.config.automatic_dynamic_shapes = False
    
    training_args.model_init_kwargs = {
        "revision": model_args.model_revision,
        "trust_remote_code": training_args.trust_remote_code,
        "attn_implementation": model_args.attn_implementation,
        "dtype": model_args.dtype,
        "device_map": None
    }
    
    if int(os.environ.get("WORLD_SIZE", "1")) > 1:
        # Модель шардируется по сетке TP x FSDP
        training_args.model_init_kwargs["distributed_config"] = DistributedConfig(
            tp_size=int(os.environ.get("TP_SIZE", "1")),
            fsdp_size=int(os.environ.get("FSDP_SIZE", "1")),
        )
    
    # Подготовка датасета
    train_dataset = load_dataset(
        script_args.dataset_name,
        name=script_args.dataset_config,
        split=script_args.dataset_train_split,
    )
    train_dataset = train_dataset.select_columns(["messages"])
    
    # Обучение
    trainer = SFTTrainer(
        model=model_args.model_name_or_path,
        args=training_args,
        train_dataset=train_dataset,
    )
    trainer.train()
    trainer.save_model(training_args.output_dir)
    trainer.end()

if __name__ == "__main__":
    parser = TrlParser((ScriptArguments, SFTConfig, ModelConfig))
    script_args, training_args, model_args = parser.parse_args_and_config()
    main(script_args, training_args, model_args)

Ключевые особенности этого подхода:

  1. Отсутствие дублирования: Тот же самый скрипт, с небольшими изменениями переменных окружения, может быть запущен на GPU или Trainium. Это упрощает CI/CD пайплайны.
  2. Нативное распределение: Параллелизм управляется через DistributedConfig в model_init_kwargs. Trainer автоматически понимает, что модель уже распределена, и не оборачивает её снова в FSDP или DDP.
  3. Статические формы: Поскольку Neuron лучше работает со статическими тензорами, мы отключаем автоматические динамические формы в torch._dynamo и используем упаковку батчей (wrapped packing) для ограничения вариативности размеров.
TorchNeuron: Запуск моделей Hugging Face на AWS Trainium без компромиссов

Запуск обучения

Для запуска обучения используется команда torchrun. Ниже приведен пример запуска на 32 процессах (что соответствует 8 чипам Trainium2, где каждый чип имеет 4 NeuronCores, но в примере используется конфигурация 4x8 сетки):

terminalbash
TP_SIZE=4 FSDP_SIZE=8 HF_DEACTIVATE_ASYNC_LOAD=1 uv run torchrun --nproc_per_node=32 sft_neuron_example.py \
    --model_name_or_path Qwen/Qwen3-8B \
    --dataset_name HuggingFaceH4/ultrachat_200k \
    --dataset_train_split train_sft \
    --output_dir Qwen3-8B-sft-tp4-fsdp8 \
    --dtype bfloat16 \
    --max_length 2048 \
    --packing true \
    --packing_strategy wrapped \
    --learning_rate 2e-5 \
    --warmup_steps 0.03 \
    --num_train_epochs 1 \
    --logging_steps 2 \
    --per_device_train_batch_size 4 \
    --gradient_accumulation_steps 4 \
    --save_only_model true \
    --torch_compile true

Обратите внимание на переменную HF_DEACTIVATE_ASYNC_LOAD=1. Асинхронная загрузка весов, встроенная в Transformers, пока не поддерживается на Neuron, поэтому её необходимо отключить. Параметр --torch_compile true включает компиляцию графов, что критически важно для достижения высокой производительности на Trainium.

💡
Важно знать. Сохраненные модели в формате Transformers полностью совместимы с другими устройствами. Вы можете загрузить чекпоинт, обученный на Trainium, и запустить его на NVIDIA GPU или CPU без каких-либо конвертаций. Это обеспечивает полную портативность ваших моделей.

04Кастомные ядра (Kernels) и оптимизация

Для продвинутых пользователей, которым требуется максимальная производительность, AWS предоставляет Neuron Kernel Interface (NKI). Это позволяет писать кастомные ядра на Python, которые компилируются в оптимизированный код для NeuronCores. Такие ядра можно публиковать в Hugging Face Hub.

Например, существуют готовые ядра для ускорения Vision Transformers, которые могут дать прирост скорости до 2.4x по сравнению со стандартным выполнением. Использование NKI дает разработчикам низкий уровень контроля над операциями, позволяя оптимизировать специфичные для задачи вычисления, которые не покрываются стандартными бэкендами.

⚠️
Ограничения. На данный момент TorchNeuron находится в стадии публичного бета-тестирования (с 20 октября 2026 года). Некоторые функции, такие как автоматическое определение динамических форм в torch.compile, могут работать некорректно. Рекомендуется следить за обновлениями в репозитории GitHub и документацией Hugging Face.

05Что это значит на практике

Внедрение TorchNeuron знаменует конец эры «второго сорта» для облачных ускорителей AWS в экосистеме Hugging Face. Теперь разработчики могут:

  1. Снижать затраты: Trainium часто предлагает более выгодное соотношение цена/производительность по сравнению с GPU NVIDIA, особенно для инференса и обучения больших моделей.
  2. Упростить разработку: Отсутствие необходимости писать специфичный код для Neuron позволяет командам фокусироваться на алгоритмах, а не на инфраструктуре.
  3. Масштабироваться: Нативная поддержка FSDP и TP позволяет эффективно использовать кластеры из сотен чипов Trainium для обучения моделей следующего поколения.

Для исследователей и инженеров, работающих в России или других регионах, где доступ к некоторым облачным сервисам может быть ограничен, понимание архитектуры TorchNeuron также полезно. Оно демонстрирует, как современные фреймворки абстрагируют аппаратное обеспечение, позволяя легко переносить модели между разными типами ускорителей. Если вы планируете мигрировать свои пайплайны с GPU на Trainium, TorchNeuron предоставляет самый прямой и поддерживаемый путь, минимизирующий риски и усилия по адаптации.

Установка доступна через стандартный pip: pip install torch-neuronx. Начните с простых моделей инференса, затем переходите к диффузионным моделям и, наконец, к обучению с использованием TRL. Экосистема Hugging Face и AWS активно развивают это направление, и уже сейчас TorchNeuron предлагает стабильный и мощный инструмент для работы с AI-моделями нового поколения.

Источник: Hugging Face ↗