> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/deepspeed-training.md).

# Обучение с DeepSpeed

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

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

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

{% hint style="warning" %}
**Многопроцессорные конфигурации с GPU класса 80GB не представлены на маркетплейсе Clore.ai.** Самые крупные доступные сейчас машины — это 4× RTX PRO 6000 Blackwell (по 96GB, всего 380GB) и 8–11× RTX 5090 (по 32GB). Ёмкость A100 / H200 / B200 продаётся как [голое железо](https://clore.ai/bare-metal) по запросу. Проверьте [Цены и доступность GPU](/guides/guides_v2-ru/nachalo-raboty/pricing.md) перед выбором размера развёртывания.
{% endhint %}

1. Перейдите на [маркетплейс CLORE.AI](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.11.0-cuda12.8-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

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

## Контрольные точки градиента

Экономьте память, пересчитывая активации:

```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         | Лучшая стабильность           |
| Включите контрольные точки градиента | Меньше памяти                 |
| Настройте размер пакета              | Лучшая пропускная способность |
| Используйте выгрузку на 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 40 ГБ | \~$0.17          | \~$4.00        | \~$0.70          |
| A100 80 ГБ | \~$0.25          | \~$6.00        | \~$1.00          |

*Цены зависят от провайдера и спроса. Проверьте* [*маркетплейс CLORE.AI*](https://clore.ai/marketplace) *актуальные тарифы.*

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

* Используйте **Spot** рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана \~13% скидки), остальные совпадают с ними
* Платите **CLORE** токенами
* Сравните цены у разных провайдеров

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

* [Дообучение LLM](/guides/guides_v2-ru/obuchenie/finetune-llm.md) - Обучение LoRA
* Инференс vLLM — разверните обученную модель
* [Руководство Hugging Face](/guides/guides_v2-ru/obuchenie/huggingface-transformers.md) - Библиотека Transformers


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/obuchenie/deepspeed-training.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.