AIKraft Agents
Главная/Блог/Гайд/Профилирование TorchNeuron на AWS…
Гайд10 мин чтения · 21 октября 2026 г.

Профилирование TorchNeuron на AWS Trainium: Часть 1

Глубокое руководство по системному профилированию инференса на AWS Trainium с использованием TorchNeuron, Neuron Explorer и анализа производительности.

Профилирование TorchNeuron на AWS Trainium: Часть 1

В мире машинного обучения существует распространенное заблуждение: многие специалисты интуитивно понимают, как заставить модели работать быстрее, но лишь единицы знают, как системно проанализировать, почему конкретная модель «тормозит». Часто проблема кроется не в архитектуре модели, а в неэффективном распределении вычислений между процессором (CPU) и ускорителем (GPU/ASIC), а также в накладных расходах на передачу данных. В этой статье мы разберем первый шаг к мастерству профилирования: как использовать инструменты AWS для анализа производительности инференса на специализированном чипе Trainium с помощью бэкенда TorchNeuron.

Это руководство создано для тех, кто начинает с нуля и не имеет опыта в низкоуровневом профилировании. Мы не просто покажем команды, а объясним физику процесса: как данные текут от Python-кода через фреймворк PyTorch, через рантайм Neuron, к аппаратным ядрам NeuronCore. Вы научитесь читать таблицы ключевых усреднений, визуализировать задержки в Neuron Explorer и понимать, почему слияние операций (fusion) дает кратный прирост скорости. В конце вы сможете самостоятельно найти «узкое горлышко» в вашей модели и устранить его.

01Архитектура взаимодействия: Neuron как бэкенд PyTorch

Прежде чем погружаться в инструменты, важно понять, как устроено взаимодействие между фреймворком PyTorch и аппаратным обеспечением AWS Trainium. AWS Trainium — это специализированный чип для глубокого обучения, созданный для эффективного обучения и инференса больших языковых моделей. Для работы с ним используется пакет torch_neuronx, который интегрируется с PyTorch через механизм расширения PrivateUse1.

Обычно PyTorch имеет выделенные ключи диспетчеризации, такие как cuda для NVIDIA GPU. Однако PrivateUse1 позволяет интегрировать новый ускоритель без необходимости модифицировать ядро PyTorch или добавлять новые ключи диспетчеризации. Это делает интеграцию легкой и совместимой с существующим кодом. Пакет torch_neuronx регистрирует Neuron как нативный бэкенд, поддерживая стандартные режимы выполнения PyTorch, включая eager execution (пошаговое выполнение), torch.compile (компиляцию графа) и стандартные API. Кроме того, через Neuron Kernel Interface (NKI) можно писать кастомные операторы для тонкой оптимизации под железо.

Понимание этого уровня абстракции критично: когда вы вызываете операцию на устройстве Neuron, PyTorch не знает о ней «из коробки». Он передает вызов в рантайм Neuron, который затем планирует выполнение на физических ядрах. Именно здесь возникают накладные расходы, которые мы будем измерять.

Схема интеграции Neuron с PyTorch через механизм PrivateUse1.
Схема интеграции Neuron с PyTorch через механизм PrivateUse1.

02Настройка профилировщика: NeuronConfig и NeuronProfiler

Для сбора метрик производительности в экосистеме AWS Trainium используются два ключевых объекта: NeuronConfig и NeuronProfiler. Они работают в связке с встроенным в PyTorch инструментом torch.profiler.

NeuronConfig отвечает за то, какие именно данные будут собраны. Вы можете выбрать режимы профилирования (например, только устройство, только рантайм или оба), указать директорию для вывода и выбрать, на каких именно ядрах NeuronCore снимать трейсы. Параметр correlate_device_time=True особенно важен: он связывает время выполнения на устройстве с временем на CPU, позволяя сравнивать их в единой таблице.

NeuronProfiler принимает этот конфиг и предоставляет колбэк export_trace, который записывает системный трейс (файл trace.json) и данные устройства. Ниже приведен пример базовой конфигурации:

terminalpython
nc = NeuronConfig(
    modes=[ProfileMode.DEVICE, ProfileMode.RUNTIME],
    profile_output_dir=OUTPUT_DIR,
    capture_enabled_for_nc='0',
    correlate_device_time=True
)
exporter = NeuronProfiler(nc)

Параметр capture_enabled_for_nc позволяет выбрать конкретные ядра для трассировки. Установка correlate_device_time=True гарантирует, что в итоговой таблице key_averages() вы увидите не только время выполнения на Neuron, но и сопоставимое время на CPU, что необходимо для выявления дисбаланса.

💡
Важно про синхронизацию. При профилировании на Neuron обязательно вызывайте torch.neuron.synchronize() внутри цикла профилирования. Без этого профилировщик может экспортировать данные до того, как устройство завершит выполнение операций, что приведет к пустым колонкам с временем на устройстве и неверным выводам.

03Инструмент визуализации: Neuron Explorer

Числа из таблицы key_averages() дают общую картину, но не показывают причинно-следственные связи. Для этого используется Neuron Explorer — браузерный просмотрщик системных трейсов, временных шкал устройств и разбивки по движкам. Он доступен через SSH-туннель или расширение Visual Studio Code.

После профилирования в выходной директории появляются файлы: системный трейс, а также пары файлов .neff (скомпилированный исполняемый файл Neuron) и .ntff (трейс аппаратных инструкций). Эти файлы связаны числовым хэшем. В Neuron Explorer можно загрузить всю директорию для системного профиля или отдельные пары .neff/.ntff для анализа только устройства.

Интерфейс Explorer организует события по «полосам» (lanes). В режиме Default группировки метки следуют шаблону instance/PID/subsystem/identifier:

  • Framework dispatch: События диспетчеризации операторов (PrivateUse1 runtime), сгруппированные по потокам.
  • Framework device: События взаимодействия с устройством (PrivateUse1 driver), сгруппированные по потокам выполнения (streams).
  • Neuron Runtime: Вызовы API Neuron Runtime, сгруппированные по логическим NeuronCore.
  • Neuron Hardware: События выполнения на оборудовании, сгруппированные по физическим NeuronCore.

Визуально время течет слева направо, а жизненный цикл события — сверху вниз. Это позволяет отследить путь одной операции от Python-вызова до выполнения на кремнии.

Интерфейс Neuron Explorer с отображением временных шкал и полос (lanes).
Интерфейс Neuron Explorer с отображением временных шкал и полос (lanes).

04Практический кейс: Профилирование RMSNorm

Чтобы продемонстрировать разницу в подходах, мы возьмем операцию RMSNorm (Root Mean Square Layer Normalization) — легкий, но важный компонент в современных архитектурах трансформеров. Мы протестируем три реализации одной и той же функции:

  1. Naive RMSNorm: Ручная реализация через отдельные операции PyTorch (умножение, среднее, обратный корень и т.д.).
  2. torch.rms_norm(): Встроенная функция PyTorch, которая компилируется в один слитный (fused) ядро Neuron.
  3. Naive + torch.compile: Ручная реализация, скомпилированная с помощью torch.compile с бэкендом Neuron.

Все скрипты используют одинаковые входные данные, конфигурацию профилировщика и расписание, что делает результаты прямо сопоставимыми. Полный код доступен в репозитории torch-neuronx.

Профиль 1: Наивные операции PyTorch

Начнем с самой простой, но неэффективной реализации. Каждая строка кода маппится на одну или несколько операций ATen и может создавать промежуточные тензоры.

terminalpython
device = torch.device('neuron')
x = torch.randn(512, dtype=torch.bfloat16, device=device)
weight = torch.ones(512, dtype=torch.bfloat16, device=device)

def rms_norm_fn(t):
    t_sq = t * t  # square
    mean_sq = t_sq.mean(dim=-1, keepdim=True)  # mean of squares
    rms = torch.rsqrt(mean_sq + 1e-6)  # 1 / sqrt(mean_sq + eps)
    return t * rms * weight  # normalize + scale

При запуске профилировщика мы указываем ProfilerActivity.PrivateUse1 для сбора активности с устройства и передаем NeuronConfig как experimental_config. Расписание профилировщика настроено так, чтобы пропустить шаги разминки (warmup) и записать только один активный шаг, исключая накладные расходы на инициализацию.

После завершения профилирования мы смотрим на таблицу key_averages(), отсортированную по self_privateuse1_time_total. Результат показывает, что три вызова aten::mul занимают почти половину времени выполнения на устройстве (49.5%).

Таблица выглядит следующим образом:

Name # Calls Self CPU Self NEURON % NEURON
aten::mul 3 60.9 μs 1,164.5 μs 49.5%
aten::add 3 26.6 μs 434.6 μs 18.5%
aten::rsqrt 3 15.6 μs 415.0 μs 17.6%
aten::mean 3 21.1 μs 340.8 μs 14.5%

Общий NEURON-время: 2.355 мс.

Каждая строка соответствует коду: aten::mul выполняется для x * x, x * rms и финального умножения на weight. aten::mean выполняет редукцию. aten::add добавляет epsilon, но также вызывает копию с хоста на устройство, так как скаляр изначально находится на CPU. aten::rsqrt вычисляет обратный корень.

В Neuron Explorer видно, что каждая операция проходит свой собственный путь: создание во фреймворке, планирование в рантайме (nrta_execute_schedule) и выполнение на оборудовании (nc_exec_running). Между операциями есть зазоры, а промежуточные тензоры (t_sq, mean_sq) материализуются в памяти, что увеличивает нагрузку.

Профиль 2: Встроенная torch.rms_norm

Теперь заменим ручную реализацию на встроенную функцию PyTorch:

terminalpython
def rms_norm_fn(t):
    return torch.rms_norm(t, [512], weight)

Neuron автоматически понижает эту операцию до одного слитного (fused) ядра. В таблице key_averages() мы видим всего одну запись:

Name # Calls Self CPU Self NEURON % NEURON
aten::_fused_rms_norm 1 47.6 μs 403.3 μs 100%

Общий NEURON-время: 403.3 мкс.

Это колоссальное ускорение. Время выполнения сократилось с 2355 мкс до 403 мкс — более чем в 5 раз. В Neuron Explorer видно, что весь процесс проходит по одному пути: один вызов диспетчеризации, одно планирование рантайма и одно событие выполнения на оборудовании. Нет зазоров между операциями, нет промежуточных тензоров.

Визуализация слитного ядра в Neuron Explorer для встроенной функции torch.rms_norm.
Визуализация слитного ядра в Neuron Explorer для встроенной функции torch.rms_norm.

Профиль 3: Наивная реализация с torch.compile

Наконец, попробуем оптимизировать нашу «наивную» функцию с помощью torch.compile:

terminalpython
@torch.compile(backend='neuron', fullgraph=True)
def naive_compiled(t):
    t_sq = t * t
    mean_sq = t_sq.mean(dim=-1, keepdim=True)
    rms = torch.rsqrt(mean_sq + 1e-6)
    return t * rms * weight

Здесь TorchDynamo захватывает байткод Python, строит граф FX, а AOTAutograd понижает его до операций ATen. Бэкенд Neuron получает весь граф целиком, а не отдельные операции. Он сам находит возможности для слияния (fusion), оптимизирует доступ к памяти и компилирует граф в один артефакт NEFF. Этот артефакт выполняется как одно аппаратное событие.

Результат в таблице:

Name # Calls Self CPU Self NEURON % NEURON
Torch-Compiled Region: 0/0 1 98.4 μs 375.5 μs 100%

Общий NEURON-время: 375.5 мкс.

Результат сопоставим с встроенной функцией (375 мкс против 403 мкс). Компилятор «понял» структуру кода и выполнил слияние автоматически. Хотя накладные расходы на CPU чуть выше (98 мкс против 47 мкс), время выполнения на устройстве минимально.

05Сравнительный анализ и выводы

Сведем все результаты в одну таблицу для наглядности:

Вариант NEURON time Self CPU time Operator calls
Naive ops 2,355 µs ~125 µs Много (разрозненные)
torch.rms_norm 403 µs ~48 µs 1 (слитный)
Naive + torch.compile 376 µs ~98 µs 1 (слитный)

Оба подхода — использование встроенной функции torch.rms_norm и применение torch.compile к наивному коду — приводят к слиянию RMSNorm в одно ядро диспетчеризации. В данных тестах оба метода сокращают время выполнения на устройстве примерно до одной шестой от времени наивной реализации.

Слияние (fusion) устраняет зазоры между выполнениями на оборудовании и избегает материализации промежуточных значений, таких как x_sq и mean_sq, которые должны были бы храниться в памяти между отдельно диспетчеризованными операциями. Это снижает нагрузку на шину памяти и увеличивает пропускную способность вычислений.

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

Для инженеров ML и MLOps-специалистов этот опыт дает четкий алгоритм действий при оптимизации моделей на AWS Trainium:

  1. Используйте key_averages() для поиска горячих точек. Отсортируйте таблицу по self_privateuse1_time_total, чтобы найти операции, которые занимают больше всего времени на устройстве. Обратите внимание на Self CPU — если оно высокое, возможно, проблема в подготовке данных или накладных расходах Python.
  2. Проверяйте трейсы в Neuron Explorer. Числа могут врать, если не учитывать контекст. Откройте трейс и посмотрите, есть ли зазоры между операциями. Если вы видите множество мелких событий вместо одного крупного, это признак отсутствия слияния.
  3. Применяйте слияние. Если операция состоит из нескольких шагов, попробуйте заменить их на встроенную функцию PyTorch (если она есть) или обернуть в @torch.compile(backend='neuron'). Компилятор часто находит возможности для оптимизации, которые неочевидны при ручном написании кода.
  4. Избегайте промежуточных тензоров. Каждый промежуточный тензор требует выделения памяти и копирования. Слияние операций позволяет вычислять результат «на лету», не сохраняя промежуточные состояния.

В следующей части серии мы углубимся в профилирование на уровне устройства. Мы откроем файлы NEFF, рассмотрим разбивку по TensorEngine, VectorEngine и прямым доступам к памяти (DMA), а также построим «крышеобразную» диаграмму (roofline), чтобы определить, ограничена ли ваша операция вычислениями или пропускной способностью памяти. Но для начала освоите базовый системный профиль — это фундамент, на котором строится вся оптимизация.

Спасибо Аритре Рой Гостипати за вдохновение для этой серии, а также Пинаку Панигхати, Самиру Араухо, Акилю Ажикодану, Эше Лакхотии и остальной команде за рецензирование.

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