> 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/prodvinutyi/multi-gpu-setup.md).

# Настройка нескольких GPU

Запускайте большие ИИ-модели на нескольких GPU на Clore.ai

Запускайте крупные модели ИИ на нескольких GPU на CLORE.AI.

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

## Когда нужна конфигурация с несколькими GPU?

{% 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 %}

| Размер модели | Вариант с одной GPU | Вариант с несколькими GPU |
| ------------- | ------------------- | ------------------------- |
| ≤13B          | RTX 3090 (Q4)       | Не требуется              |
| 30B           | RTX 4090 (Q4)       | 2x RTX 3090               |
| 70B           | A100 40 ГБ (Q4)     | 2x RTX 4090               |
| 70B FP16      | -                   | 2x A100 80 ГБ             |
| 100B+         | -                   | 4x A100 80GB              |
| 405B          | -                   | 8x A100 80 ГБ             |

***

## Концепции работы на нескольких GPU

### Тензорный параллелизм (TP)

Разделите слои модели между GPU. Лучше всего подходит для инференса.

```
GPU 0: Слои 1–20
GPU 1: Слои 21–40
```

**Плюсы:** Меньшая задержка, простая настройка **Минусы:** Требуется высокоскоростное соединение

### Пайплайновый параллелизм (PP)

Обрабатывайте разные батчи на разных GPU.

```
GPU 0: Батч 1 → GPU 1: Батч 1
GPU 0: Батч 2 → GPU 1: Батч 2
```

**Плюсы:** Более высокая пропускная способность **Минусы:** Большая задержка, более сложная схема

### Параллелизм данных (DP)

Одна и та же модель на нескольких GPU, разные данные.

```
GPU 0: Обрабатывает батч A
GPU 1: Обрабатывает батч B
```

**Плюсы:** Простой линейный масштабируемый подход **Минусы:** Каждой GPU нужна полная модель

***

## Настройка LLM на нескольких GPU

### vLLM (рекомендуется)

**2 GPU:**

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-70B-Instruct \\
    --tensor-parallel-size 2 \
    --host 0.0.0.0
```

**4 GPU:**

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-70B-Instruct \\
    --tensor-parallel-size 4 \
    --host 0.0.0.0
```

**8 GPU (для 405B):**

```bash
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-405B-Instruct \\
    --tensor-parallel-size 8 \
    --host 0.0.0.0
```

### Мульти-GPU в Ollama

Ollama автоматически использует несколько GPU, если они доступны:

```bash
# Проверьте доступные GPU
nvidia-smi

# Ollama автоматически определит и использует все GPU
ollama run llama3.1:70b
```

**Ограничить конкретными GPU:**

```bash
CUDA_VISIBLE_DEVICES=0,1 ollama run llama3.1:70b
```

### Text Generation Inference (TGI)

```bash
docker run --gpus all -p 8080:80 \",
    ghcr.io/huggingface/text-generation-inference:latest \",
    --model-id meta-llama/Llama-3.1-70B-Instruct \\
    --num-shard 2
```

### llama.cpp

```bash
# Укажите количество слоёв GPU на устройство
./llama-server \\
    -m llama-3.1-70b-q4.gguf \\
    -ngl 999 \\
    --split-mode layer \\
    --tensor-split 0.5,0.5
```

***

## Генерация изображений на нескольких GPU

### ComfyUI

ComfyUI может распределять разные модели по разным GPU:

```python
# В рабочем процессе ComfyUI
# Используйте "Load Checkpoint" с параметром device
# device: "cuda:0" для первой GPU
# device: "cuda:1" для второй GPU
```

**Запуск VAE на отдельной GPU:**

```python
# Основная модель на GPU 0
# VAE на GPU 1
# Снижает нагрузку на VRAM
```

### Веб-интерфейс Stable Diffusion

**Включите multi-GPU в webui-user.sh:**

```bash
export COMMANDLINE_ARGS="--device-id 0"
# Или для конкретных моделей:
export COMMANDLINE_ARGS="--lowvram --device-id 0,1"
```

### Мульти-GPU для FLUX

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)

# Распределить по GPU
pipe.enable_model_cpu_offload()  # или
pipe.to("cuda:0")  # Явный выбор GPU
```

***

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

### Распределённый PyTorch

```python
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

# Инициализация
dist.init_process_group("nccl")
local_rank = int(os.environ["LOCAL_RANK"] )
torch.cuda.set_device(local_rank)

# Оберните модель
model = YourModel().to(local_rank)
model = DDP(model, device_ids=[local_rank])

# Цикл обучения как обычно
```

**Запуск:**

```bash
torchrun --nproc_per_node=2 train.py
```

### DeepSpeed

```python
import deepspeed

model, optimizer, _, _ = deepspeed.initialize(
    model=model,
    config={
        "train_batch_size": 32,
        "fp16": {"enabled": True},
        "zero_optimization": {"stage": 2}
    }
)
```

**Запуск:**

```bash
deepspeed --num_gpus=2 train.py
```

### Accelerate (HuggingFace)

```python
from accelerate import Accelerator

accelerator = Accelerator()
model, optimizer, dataloader = accelerator.prepare(
    model, optimizer, dataloader
)
```

**Настройте:**

```bash
accelerate config  # Интерактивная настройка
accelerate launch train.py
```

### Обучение Kohya (LoRA)

```bash
# Обучение LoRA на нескольких GPU
accelerate launch --num_processes=2 train_network.py \\
    --pretrained_model_name_or_path="model.safetensors" \\
    --train_data_dir="./images" \\
    --output_dir="./output"
```

***

## Выбор GPU

### Проверьте доступные GPU

```bash
# Список всех GPU
nvidia-smi

# Подробная информация
nvidia-smi -L

# Использование памяти
nvidia-smi --query-gpu=index,memory.used,memory.total --format=csv
```

### Выберите конкретные GPU

**Переменная окружения:**

```bash
# Использовать только GPU 0 и 1
export CUDA_VISIBLE_DEVICES=0,1
python your_script.py

# Использовать только GPU 2
export CUDA_VISIBLE_DEVICES=2
python your_script.py
```

**В Python:**

```python
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"

# Или с torch
import torch
device = torch.device("cuda:0")  # Первая видимая GPU
device = torch.device("cuda:1")  # Вторая видимая GPU
```

***

## Оптимизация производительности

### NVLink против PCIe

| Соединение | Пропускная способность | Лучше всего для       |
| ---------- | ---------------------- | --------------------- |
| NVLink     | 600 ГБ/с               | Тензорный параллелизм |
| PCIe 4.0   | 32 ГБ/с                | Параллелизм данных    |
| PCIe 5.0   | 64 ГБ/с                | Смешанные нагрузки    |

**Проверьте статус NVLink:**

```bash
nvidia-smi nvlink --status
```

### Оптимальная конфигурация

| GPU | Размер TP | Размер PP | Примечания                    |
| --- | --------- | --------- | ----------------------------- |
| 2   | 2         | 1         | Простой тензорный параллелизм |
| 4   | 4         | 1         | Требуется NVLink              |
| 4   | 2         | 2         | Совместимо с PCIe             |
| 8   | 8         | 1         | Полный тензорный параллелизм  |
| 8   | 4         | 2         | Смешанный параллелизм         |

### Балансировка памяти

**Равномерное разделение (по умолчанию):**

```bash
--tensor-parallel-size 2
```

**Пользовательское разделение (неравные GPU):**

```bash
# vLLM не поддерживает неравномерное разделение, используйте llama.cpp:
./llama-server --tensor-split 0.6,0.4
```

***

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

### "Ошибка NCCL"

```bash
# Включите отладку NCCL
export NCCL_DEBUG=INFO

# Попробуйте разные алгоритмы NCCL
export NCCL_ALGO=Ring
```

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

```bash
# Проверьте память по каждой GPU
nvidia-smi

# Уменьшите размер батча
--max-batch-size 1

# Включите checkpointing градиентов (обучение)
--gradient-checkpointing
```

### "Низкая производительность при работе с несколькими GPU"

1. Проверьте наличие NVLink-соединения
2. Уменьшите размер тензорного параллелизма
3. Вместо этого используйте пайплайновый параллелизм
4. Проверьте узкое место CPU

### "GPU не обнаружены"

```bash
# Проверьте CUDA
nvidia-smi

# Проверьте, видит ли PyTorch GPU
python -c "import torch; print(torch.cuda.device_count())"

# При необходимости переустановите драйверы CUDA
```

***

## Оптимизация затрат

### Когда мульти-GPU оправдан

| Сценарий                 | Одна GPU                                                 | Несколько GPU                                               | Победитель         |
| ------------------------ | -------------------------------------------------------- | ----------------------------------------------------------- | ------------------ |
| Редкое использование 70B | A100 80 ГБ ([голое железо](https://clore.ai/bare-metal)) | 2x RTX 4090 ($0.28–0.84/час)                                | Мульти-GPU         |
| Продакшен 70B            | A100 40GB ([голое железо](https://clore.ai/bare-metal))  | 2x A100 40 ГБ ([голое железо](https://clore.ai/bare-metal)) | Одна (Q4)          |
| Обучение 7B              | RTX 4090 ($0.14–0.42/час)                                | 2x RTX 4090 ($0.28–0.84/час)                                | Зависит от времени |

### Экономичные конфигурации

| Сценарий использования | Конфигурация  | \~Стоимость/час |
| ---------------------- | ------------- | --------------- |
| Инференс 70B           | 2x RTX 3090   | $0.12           |
| Быстрый инференс 70B   | 2x A100 40 ГБ | $0.34           |
| 70B FP16               | 2x A100 80 ГБ | $0.50           |
| Обучение 13B           | 2x RTX 4090   | $0.20           |

***

## Примеры конфигураций

### Сервер чата 70B

```bash
# Конфигурация 2x A100 40 ГБ
python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-70B-Instruct \\
    --tensor-parallel-size 2 \
    --max-model-len 8192 \
    --host 0.0.0.0 \
    --port 8000
```

### DeepSeek-V3 (671B)

```bash
# Требуется 8x A100 80 ГБ
python -m vllm.entrypoints.openai.api_server \\
    --model deepseek-ai/DeepSeek-V3 \\
    --tensor-parallel-size 8 \
    --trust-remote-code \\
    --host 0.0.0.0
```

### Пайплайн изображение + LLM

```bash
# GPU 0: Stable Diffusion
CUDA_VISIBLE_DEVICES=0 python comfyui/main.py --port 8188 &

# GPU 1: LLM для подсказок
CUDA_VISIBLE_DEVICES=1 python -m vllm.entrypoints.openai.api_server \\
    --model meta-llama/Llama-3.1-8B-Instruct --port 8000
```

***

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

* [Руководство по vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) - Обслуживание LLM в продакшене
* [Сравнение GPU](/guides/guides_v2-ru/nachalo-raboty/gpu-comparison.md) - Выберите свои GPU
* [Интеграция API](/guides/guides_v2-ru/prodvinutyi/api-integration.md) - Создавайте приложения
* [Калькулятор стоимости](/guides/guides_v2-ru/nachalo-raboty/cost-calculator.md) - Оценивайте затраты


---

# 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/prodvinutyi/multi-gpu-setup.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.