distributed-llm-pretraining-torchtitan

Configure 4D parallel distributed LLM pretraining with FSDP2, tensor, pipeline, and context parallelism.

2|Updated Apr 12, 2026
One-click install
npx skills add https://github.com/Clay-HHK/claude-config --skill distributed-llm-pretraining-torchtitan-clay-hhk
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: distributed-llm-pretraining-torchtitan
Source: https://github.com/Clay-HHK/claude-config/tree/main/skills/AI-research-SKILLs/01-model-architecture/torchtitan
Command: npx skills add https://github.com/Clay-HHK/claude-config --skill distributed-llm-pretraining-torchtitan-clay-hhk

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Managing and executing large-scale LLM pretraining workflows is complex and error-prone due to multi-dimensional parallelism, memory constraints, checkpoint interoperability, and performance tuning for modern accelerators. This Skill consolidates best-practice configurations and operational guidance to reliably pretrain models from 8 to 512+ GPUs while maximizing throughput and fault tolerance.

Core Features & Use Cases

  • Composable 4D parallelism: Guides for FSDP2, tensor parallelism, pipeline parallelism, and context parallelism to scale models across nodes and GPUs.
  • Performance optimizations: Float8 integration, torch.compile usage, activation checkpointing, and microbench-informed filtering to boost H100 throughput.
  • Checkpointing & interoperability: Distributed Checkpoint (DCP) patterns, async checkpointing, and conversion paths to/from HuggingFace formats for recovery and fine-tuning.
  • Use Cases: Single-node 8-GPU pretraining of Llama 3.1 8B, multi-node SLURM jobs for 70B+ models, and large-scale 4D parallel pretraining for 405B+ models with seed checkpoints for pipeline parallelism.

Quick Start

Launch a pretraining run by creating or editing your TOML config for the target model and running the run_train.sh entrypoint with that config file.

Frequently Asked Questions about distributed-llm-pretraining-torchtitan

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I scale PyTorch LLM pretraining to 512+ GPUs using FSDP2?

Scale PyTorch LLM pretraining by applying composable 4D parallelism (FSDP2, tensor, pipeline, and context parallelism) to distribute large models across nodes. Configure your TOML file and launch the run_train.sh entrypoint to manage workloads from 8 to 512+ GPUs.

What is composable 4D parallelism in distributed training?

Composable 4D parallelism combines FSDP2, tensor parallelism, pipeline parallelism, and context parallelism to efficiently scale large language models across multi-node clusters. This approach maximizes throughput while managing memory constraints for models like Llama 3.1 405B.

Can I use Float8 and torch.compile to accelerate H100 throughput for Llama 3.1 pretraining?

Yes, you can accelerate H100 throughput by integrating Float8 and torch.compile during Llama 3.1 pretraining. Additional performance optimizations include activation checkpointing and microbench-informed filtering to maximize training efficiency.

How do I convert PyTorch Distributed Checkpoints to HuggingFace format for fine-tuning?

Convert PyTorch Distributed Checkpoints (DCP) to HuggingFace formats using established interoperability patterns. This enables seamless recovery and downstream fine-tuning workflows for models pretrained with FSDP2 sharding.

Does torchtitan support multi-node SLURM clusters for 70B+ model pretraining?

Yes, torchtitan supports multi-node SLURM jobs for pretraining 70B+ models. It provides operational guidance and best-practice configurations to reliably execute large-scale distributed training across single-node and multi-node SLURM clusters.

What's the best way to configure pipeline parallelism for 405B+ models?

Configure pipeline parallelism for 405B+ models by utilizing seed checkpoints and composable 4D parallelism. This approach ensures efficient scaling and fault tolerance while maintaining high throughput during large-scale distributed training.