DeepSpeed — обучение

Эффективно обучайте большие модели с DeepSpeed на GPU Clore.ai

Эффективно обучайте большие модели с помощью Microsoft DeepSpeed.

Все примеры можно запускать на GPU-серверах, арендуемых через CLORE.AI Marketplace.

Аренда на CLORE.AI

1. Посетите CLORE.AI Marketplace

2. Отфильтруйте по типу GPU, объему VRAM и цене

3. Выберите On-Demand (фиксированная ставка) или Spot (цена по ставке)

4. Настройте ваш заказ:

   • Выберите Docker-образ

   • Установите порты (TCP для SSH, HTTP для веб-интерфейсов)

   • Добавьте переменные окружения при необходимости

   • Введите команду запуска

5. Выберите способ оплаты: CLORE, BTC, или USDT/USDC

6. Создайте заказ и дождитесь развертывания

Доступ к вашему серверу

• Найдите данные для подключения в Моих заказах

• Веб-интерфейсы: используйте URL HTTP-порта

• SSH: ssh -p <port> root@<proxy-address>

Что такое DeepSpeed?

DeepSpeed позволяет:

• Обучать модели, которые не помещаются в память GPU

• Обучение на нескольких GPU и в нескольких узлах

• Оптимизация ZeRO (эффективность использования памяти)

• Обучение с смешанной точностью

Стадии ZeRO

Стадия	Экономия памяти	Скорость
ZeRO-1	Состояния оптимизатора распределены	Быстро
ZeRO-2	+ Градиенты распределены	Сбалансировано
ZeRO-3	+ Параметры распределены	Максимальная экономия
ZeRO-Infinity	Выгрузка на CPU/NVMe	Крупнейшие модели

Быстрое развертывание

Docker-образ:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Порты:

22/tcp

Команда:

pip install deepspeed transformers datasets accelerate

Установка

pip install deepspeed

# Проверить установку
ds_report

Базовое обучение

Конфигурация DeepSpeed

ds_config.json:

{
    "train_batch_size": 32,
    "gradient_accumulation_steps": 4,
    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": 1e-4,
            "betas": [0.9, 0.999],
            "eps": 1e-8,
            "weight_decay": 0.01
        }
    },
    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": 0,
            "warmup_max_lr": 1e-4,
            "warmup_num_steps": 100
        }
    },
    "fp16": {
        "enabled": true,
        "loss_scale": 0,
        "initial_scale_power": 16
    },
    "zero_optimization": {
        "stage": 2,
        "contiguous_gradients": true,
        "overlap_comm": true
    }
}

Скрипт обучения

import torch
import deepspeed
from transformers import AutoModelForCausalLM, AutoTokenizer

# Инициализация
model = AutoModelForCausalLM.from_pretrained("gpt2")
tokenizer = AutoTokenizer.from_pretrained("gpt2")

# Инициализация DeepSpeed
model_engine, optimizer, _, _ = deepspeed.initialize(
    model=model,
    model_parameters=model.parameters(),
    config="ds_config.json"
)

# Цикл обучения
for epoch in range(num_epochs):
    for batch in dataloader:
        inputs = tokenizer(batch["text"], return_tensors="pt", padding=True, truncation=True)
        inputs = {k: v.to(model_engine.device) for k, v in inputs.items()}

        outputs = model_engine(**inputs, labels=inputs["input_ids"])
        loss = outputs.loss

        model_engine.backward(loss)
        model_engine.step()

Конфигурация ZeRO Stage 2

{
    "train_batch_size": "auto",
    "gradient_accumulation_steps": "auto",
    "gradient_clipping": 1.0,
    "fp16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 2,
        "allgather_partitions": true,
        "allgather_bucket_size": 2e8,
        "reduce_scatter": true,
        "reduce_bucket_size": 2e8,
        "overlap_comm": true
    }
}

Конфигурация ZeRO Stage 3

Для больших моделей:

{
    "train_batch_size": "auto",
    "gradient_accumulation_steps": "auto",
    "fp16": {
        "enabled": true
    },
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "sub_group_size": 1e9,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "stage3_max_live_parameters": 1e9,
        "stage3_max_reuse_distance": 1e9,
        "stage3_gather_16bit_weights_on_model_save": true
    }
}

С Hugging Face Transformers

Интеграция с Trainer

from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="./output",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=1e-4,
    num_train_epochs=3,
    fp16=True,
    deepspeed="ds_config.json",
    logging_steps=10,
    save_steps=500,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    tokenizer=tokenizer,
)

trainer.train()

Обучение на нескольких GPU

Команда запуска

# Один узел, 4 GPU
deepspeed --num_gpus=4 train.py --deepspeed ds_config.json

# Конкретные GPU
deepspeed --include="localhost:0,1,2,3" train.py --deepspeed ds_config.json

С torchrun

torchrun --nproc_per_node=4 train.py --deepspeed ds_config.json

Обучение в нескольких узлах

Файл хостов

hostfile:

node1 slots=4
node2 slots=4

Запуск

deepspeed --hostfile=hostfile train.py --deepspeed ds_config.json

Настройка SSH

# Обеспечьте SSH без пароля между узлами
ssh-keygen -t rsa
ssh-copy-id user@node2

Конфигурации, экономящие память

Модель 7B на GPU с 24 ГБ

{
    "bf16": {"enabled": true},
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"}
    },
    "gradient_checkpointing": true,
    "train_micro_batch_size_per_gpu": 1,
    "gradient_accumulation_steps": 16
}

Модель 13B на GPU с 24 ГБ

{
    "bf16": {"enabled": true},
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"},
        "stage3_param_persistence_threshold": 0
    },
    "gradient_checkpointing": true,
    "train_micro_batch_size_per_gpu": 1,
    "gradient_accumulation_steps": 32
}

Gradient Checkpointing

Экономия памяти за счёт пересчёта активаций:

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
model.gradient_checkpointing_enable()

Сохранение и загрузка чекпоинтов

Сохранить

# Чекпоинтинг обрабатывается DeepSpeed
model_engine.save_checkpoint("./checkpoints", tag="step_1000")

Загрузить

model_engine.load_checkpoint("./checkpoints", tag="step_1000")

Сохранить в формате HuggingFace

# Конвертировать чекпоинт DeepSpeed в формат HF
from deepspeed.utils.zero_to_fp32 import get_fp32_state_dict_from_zero_checkpoint

state_dict = get_fp32_state_dict_from_zero_checkpoint("./checkpoints/step_1000")
model.load_state_dict(state_dict)
model.save_pretrained("./hf_model")

Мониторинг

TensorBoard

{
    "tensorboard": {
        "enabled": true,
        "output_path": "./logs",
        "job_name": "training_run"
    }
}

Weights & Biases

{
    "wandb": {
        "enabled": true,
        "project": "my_project"
    }
}

Распространённые проблемы

Недостаточно памяти

// Попробуйте:
{
    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {"device": "cpu"},
        "offload_param": {"device": "cpu"}
    },
    "train_micro_batch_size_per_gpu": 1
}

Медленное обучение

• Уменьшите выгрузку на CPU

• Увеличьте размер батча

• Используйте ZeRO Stage 2 вместо 3

Ошибки NCCL

# Установите переменные окружения
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1

Советы по производительности

Совет	Эффект
Используйте bf16 вместо fp16	Лучшая стабильность
Включите gradient checkpointing	Меньше памяти
Настройте размер батча	Лучший пропускной поток
Используйте выгрузку на NVMe	Более крупные модели

Сравнение производительности

Модель	GPU	Стадия ZeRO	Скорость обучения
7B	1x A100	ZeRO-3	~1000 токенов/с
7B	4x A100	ZeRO-2	~4000 токенов/с
13B	4x A100	ZeRO-3	~2000 токенов/с
70B	8x A100	ZeRO-3	~800 токенов/с

Устранение неполадок

Оценка стоимости

Типичные ставки на маркетплейсе CLORE.AI (по состоянию на 2024):

GPU	Почасовая ставка	Дневная ставка	Сессия 4 часа
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Цены варьируются в зависимости от провайдера и спроса. Проверьте CLORE.AI Marketplace для текущих тарифов.

Экономьте деньги:

• Используйте Spot рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)

• Платите с помощью CLORE токенов

• Сравнивайте цены у разных провайдеров

Дальнейшие шаги

• Тонкая настройка LLM - Обучение LoRA

• vLLM Inference - Развернуть обученную модель

• Руководство Hugging Face - Библиотека Transformers