Децентрализованные 4090 vs AWS H100: калькулятор для тонкой настройки Llama 3 70B

Проблема выбора: облако vs своё железо для тонкой настройки

Перед каждым инженером, который планирует тонкую настройку Llama 3 70B, стоит классическая дилемма: арендовать мощные H100 в облаке или собрать ферму из потребительских RTX 4090. Эта статья — не просто сравнение характеристик, а практический калькулятор для принятия решения на основе ваших конкретных задач и бюджета.

Технические характеристики: что на бумаге и что на практике

На бумаге H100 кажется монстром, но реальная производительность в задачах тонкой настройки зависит от множества факторов: эффективности распределения модели между картами, качества межкарточного соединения и оптимизации кода.

1Калькулятор стоимости: считаем реальные цифры

Давайте создадим простой калькулятор на Python, который поможет принять решение. Мы будем учитывать:

• Стоимость железа (капитальные затраты)
• Энергопотребление и охлаждение
• Стоимость аренды в облаке
• Время обучения (операционные затраты)

#!/usr/bin/env python3
# Калькулятор стоимости тонкой настройки Llama 3 70B

class FineTuningCalculator:
    def __init__(self):
        # Конфигурация
        self.model_size_gb = 140  # Llama 3 70B в BF16
        self.training_days = 7    # Дней обучения
        self.batch_size = 4       # Размер батча
        self.dataset_size = 1000000  # Пример размера датасета
        
        # Стоимость оборудования
        self.rtx4090_price = 2000      # USD за карту
        self.rtx4090_power = 450       # Ватт под нагрузкой
        self.rtx4090_vram = 24         # ГБ
        
        self.h100_price = 35000        # USD за карту
        self.h100_power = 700          # Ватт под нагрузкой
        self.h100_vram = 80            # ГБ
        
        # Облачные цены (AWS)
        self.aws_p5_hourly = 98.32     # USD/час за 8xH100
        self.aws_p4d_hourly = 32.77    # USD/час за 8xA100
        
        # Электричество
        self.electricity_cost = 0.15   # USD за кВт·ч
        
    def calculate_rtx4090_cluster(self):
        """Рассчитываем стоимость фермы из RTX 4090"""
        # Сколько карт нужно для модели
        cards_needed = self.model_size_gb // self.rtx4090_vram + 1
        cards_needed = max(cards_needed, 4)  # Минимум 4 карты
        
        # Стоимость оборудования
        gpu_cost = cards_needed * self.rtx4090_price
        
        # Стоимость остального железа (материнка, память, БП)
        # Более детально про сборку можно узнать в нашей статье 
        # Как собрать мощную станцию для локальных LLM за $15 000
        other_hardware = 5000  # USD
        
        # Энергопотребление
        total_power_w = cards_needed * self.rtx4090_power + 500  # +500 для системы
        power_kwh = total_power_w / 1000 * 24 * self.training_days
        electricity_cost = power_kwh * self.electricity_cost
        
        # Охлаждение (примерно 30% от энергозатрат)
        cooling_cost = electricity_cost * 0.3
        
        total_investment = gpu_cost + other_hardware
        operational_cost = electricity_cost + cooling_cost
        
        return {
            'cards_needed': cards_needed,
            'total_investment': total_investment,
            'operational_cost': operational_cost,
            'total_cost_30days': total_investment + operational_cost,
            'power_consumption_kwh': power_kwh
        }
    
    def calculate_aws_h100(self):
        """Рассчитываем стоимость аренды H100 в AWS"""
        hours_needed = self.training_days * 24
        
        # Используем p5.48xlarge (8xH100)
        compute_cost = hours_needed * self.aws_p5_hourly
        
        # Хранение данных и трафик (примерно 10% от compute)
        storage_cost = compute_cost * 0.1
        
        total_cost = compute_cost + storage_cost
        
        return {
            'instance_type': 'p5.48xlarge',
            'compute_cost': compute_cost,
            'storage_cost': storage_cost,
            'total_cost': total_cost,
            'hours_needed': hours_needed
        }
    
    def calculate_roi(self, rtx_cost, aws_cost):
        """Рассчитываем точку окупаемости"""
        # Сколько дней обучения нужно, чтобы окупить ферму 4090
        daily_aws_cost = aws_cost['total_cost'] / self.training_days
        days_to_roi = rtx_cost['total_investment'] / daily_aws_cost
        
        return {
            'daily_aws_cost': daily_aws_cost,
            'days_to_roi': days_to_roi,
            'profitable_after_days': days_to_roi if days_to_roi > 0 else 'never'
        }
    
    def print_comparison(self):
        """Выводим сравнение"""
        rtx = self.calculate_rtx4090_cluster()
        aws = self.calculate_aws_h100()
        roi = self.calculate_roi(rtx, aws)
        
        print("=" * 60)
        print(f"СРАВНЕНИЕ ДЛЯ Llama 3 70B ({self.training_days} дней обучения)")
        print("=" * 60)
        print(f"\nRTX 4090 КЛАСТЕР ({rtx['cards_needed']} карт):")
        print(f"  Инвестиции: ${rtx['total_investment']:,.2f}")
        print(f"  Операционные затраты: ${rtx['operational_cost']:,.2f}")
        print(f"  Всего за {self.training_days} дней: ${rtx['total_cost_30days']:,.2f}")
        print(f"  Потребление: {rtx['power_consumption_kwh']:,.0f} кВт·ч")
        
        print(f"\nAWS H100 (p5.48xlarge):")
        print(f"  Вычислительные затраты: ${aws['compute_cost']:,.2f}")
        print(f"  Хранение/трафик: ${aws['storage_cost']:,.2f}")
        print(f"  Всего за {self.training_days} дней: ${aws['total_cost']:,.2f}")
        
        print(f"\nАНАЛИЗ ОКУПАЕМОСТИ:")
        print(f"  Стоимость AWS в день: ${roi['daily_aws_cost']:,.2f}")
        print(f"  Ферма 4090 окупится через: {roi['days_to_roi']:.1f} дней обучения")
        
        if roi['days_to_roi'] < 30:
            print(f"  🟢 ВЫГОДНО: своя ферма окупается менее чем за месяц")
        elif roi['days_to_roi'] < 90:
            print(f"  🟡 УМЕРЕННО: окупаемость 1-3 месяца")
        else:
            print(f"  🔴 НЕВЫГОДНО: лучше использовать облако")

if __name__ == "__main__":
    calc = FineTuningCalculator()
    calc.print_comparison()

2Производительность в реальных задачах

Теоретические TFLOPS — это одно, а реальная скорость обучения — совсем другое. Давайте сравним ключевые метрики:

Разница в 2-3 раза в скорости объясняется не только raw производительностью, но и архитектурными преимуществами:

• NVLink на H100 обеспечивает 900 ГБ/с пропускной способности между картами, против 64 ГБ/с у PCIe 4.0
• Тензорные ядра 4-го поколения на H100 оптимизированы именно для трансформеров
• HBM3 память имеет в 3 раза большую пропускную способность, чем GDDR6X

Практическая настройка: шаг за шагом

3Настройка фермы из RTX 4090

Если вы выбрали путь децентрализованных вычислений, вот ключевые шаги:

# 1. Сборка железа (минимальная конфигурация для Llama 3 70B)
# - 4× RTX 4090 (рекомендую начать с 2 и масштабироваться)
# - Материнская плата с 4× PCIe 4.0 x16 (или x8/x8/x8/x8)
# - CPU с минимум 32 ядрами (AMD Threadripper или Intel Xeon)
# - 256 ГБ DDR4/DDR5 RAM
# - Блок питания 1600W+ (лучше 2000W для запаса)
# - Система охлаждения (минимум 6×120mm вентиляторов)

# 2. Установка ПО
sudo apt update
sudo apt install -y nvidia-driver-545 nvidia-docker2 docker.io

# 3. Настройка Docker для multi-GPU
echo '{
    "default-runtime": "nvidia",
    "runtimes": {
        "nvidia": {
            "path": "nvidia-container-runtime",
            "runtimeArgs": []
        }
    }
}' | sudo tee /etc/docker/daemon.json

sudo systemctl restart docker

# 4. Запуск контейнера с поддержкой всех GPU
docker run --gpus all -it --rm \
  -v $(pwd):/workspace \
  -p 8888:8888 \
  pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime

Для эффективного распределения модели используйте DeepSpeed или FSDP (Fully Sharded Data Parallel). Пример конфигурации:

{
  "train_batch_size": 4,
  "gradient_accumulation_steps": 8,
  "fp16": {
    "enabled": true,
    "loss_scale": 0,
    "loss_scale_window": 1000,
    "initial_scale_power": 16,
    "hysteresis": 2,
    "min_loss_scale": 1
  },
  "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
  },
  "gradient_clipping": 1.0,
  "steps_per_print": 2000,
  "wall_clock_breakdown": false
}

4Настройка AWS H100 (p5 instance)

Для облачного подхода настройка проще, но дороже:

# 1. Создание инстанса p5.48xlarge
# Через AWS Console или CLI:
aws ec2 run-instances \
  --instance-type p5.48xlarge \
  --image-id ami-0c55b159cbfafe1f0 \
  --key-name your-key-pair \
  --security-group-ids sg-xxxxxxxx \
  --subnet-id subnet-xxxxxxxx \
  --block-device-mappings '[{"DeviceName":"/dev/sda1","Ebs":{"VolumeSize":500}}]'

# 2. Установка NVIDIA AI Enterprise (опционально, но рекомендовано)
sudo apt install -y nvidia-ai-enterprise

# 3. Настройка EFA для межнодовой коммуникации (если масштабируетесь)
sudo apt install -y aws-efa-installer

# 4. Запуск обучения с оптимизацией под H100
export NCCL_DEBUG=INFO
export NCCL_IB_HCA=mlx5_0
export FI_EFA_USE_DEVICE_RDMA=1

# 5. Использование оптимизаций TensorRT-LLM для H100
python -m pip install tensorrt_llm --extra-index-url https://pypi.nvidia.com

# Пример запуска с оптимизациями
python train.py \
  --model_name_or_path meta-llama/Llama-3-70b \
  --use_flash_attention_2 \
  --bf16 \
  --tf32 \
  --gradient_checkpointing \
  --optim adamw_bnb_8bit \
  --lr_scheduler_type cosine \
  --learning_rate 2e-5 \
  --warmup_ratio 0.03 \
  --num_train_epochs 3 \
  --per_device_train_batch_size 8 \
  --gradient_accumulation_steps 4

Скрытые затраты и подводные камни

При принятии решения учитывайте не только прямые затраты:

Оптимизационные стратегии для каждого подхода

Для RTX 4090 фермы:

• Квантование QLoRA: Используйте 4-битное квантование для уменьшения требований к памяти
• Градиентный чекипоинтинг: Trade-off между памятью и скоростью
• CPU offloading: Часть вычислений на CPU для экономии VRAM
• Пайплайн параллелизм: Разные слои на разные карты

Для AWS H100:

• Spot instances: Экономия до 70% при использовании прерываемых инстансов
• Reserved Instances: Скидка 40-60% при долгосрочной аренде
• Savings Plans: Гибкая модель оплаты для нерегулярных нагрузок
• Multi-node training: Масштабирование на десятки H100 для ультра-быстрого обучения

Кейсы и рекомендации

FAQ: Часто задаваемые вопросы

Заключение: что выбрать в 2024?

Решение зависит от вашего конкретного случая:

• Выбирайте ферму RTX 4090 если: у вас есть капитал на инвестиции, планируете активно использовать железо 2+ года, есть экспертиза по настройке железа, или нужна полная контроль над инфраструктурой.
• Выбирайте AWS H100 если: скорость обучения критична, бюджет ограничен (нет $20k+ на железо), нужна максимальная масштабируемость, или вы проводите эксперименты с разной конфигурацией.

Лично я рекомендую начать с облака для первых экспериментов, оценить реальные потребности в вычислениях, и только потом принимать решение о покупке железа. Помните: самое дорогое — это не железо, а время инженеров, потраченное на его настройку и поддержку.

Для тех, кто хочет углубиться в тему локального железа, рекомендую наши статьи про бюджетную 4-GPU ферму и сравнение локальных моделей с GPT-4.