# Обучение DeepSpeed

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

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://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
```

**Команда:**

```bash
pip install deepspeed transformers datasets accelerate
```

## Установка

```bash
pip install deepspeed

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

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

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

**ds\_config.json:**

```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
    }
}
```

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

```python
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

```json
{
    "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

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

```json
{
    "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

```python
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

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

```bash

# Один узел, 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

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

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

### Файл хостов

**hostfile:**

```
node1 slots=4
node2 slots=4
```

### Запуск

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

### Настройка SSH

```bash

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

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

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

```json
{
    "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 ГБ

```json
{
    "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

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

```python
from transformers import AutoModelForCausalLM

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

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

### Сохранить

```python

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

### Загрузить

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

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

```python

# Конвертировать чекпоинт 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

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

### Weights & Biases

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

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

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

```json
// Попробуйте:
{
    "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

```bash

# Установите переменные окружения
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*](https://clore.ai/marketplace) *для текущих тарифов.*

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

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены у разных провайдеров

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

* [Тонкая настройка LLM](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/finetune-llm) - Обучение LoRA
* vLLM Inference - Развернуть обученную модель
* [Руководство Hugging Face](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/huggingface-transformers) - Библиотека Transformers