> 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 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](/guides/guides_v2-ru/obuchenie/finetune-llm.md) - Обучение LoRA
* vLLM Inference - Развернуть обученную модель
* [Руководство 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.