Estimate Complexity

Step-by-Step Reasoning for Estimating GPT-3 Training FLOPs

To estimate the total floating-point operations (FLOPs) required to train GPT-3, I'll rely on key architectural and training details I recall about the model, combined with a standard approximation formula for transformer training compute. This is an order-of-magnitude estimate, as exact figures aren't memorized, but it aligns with widely discussed scaling laws in AI research (e.g., from papers like Kaplan et al. on scaling laws or Hoffmann et al. on Chinchilla). I'll avoid any online lookup and base this purely on recollection.

Step 1: Recall GPT-3's Key Specifications

• Model size (number of parameters, N): GPT-3 is a dense transformer with 175 billion parameters. That's N = 175 × 10^9 = 1.75 × 10^11 parameters.
• Dataset size (number of tokens, D): GPT-3 was trained on a large corpus called Common Crawl (filtered and processed), totaling around 300 billion tokens. This is a common estimate I've seen cited in discussions; it's roughly equivalent to ~570 GB of uncompressed text, assuming ~5-6 characters per token on average, but we work in tokens for compute estimates. So, D ≈ 3 × 10^11 tokens.
• Other assumptions: Training used standard techniques like Adam optimizer, with a batch size, learning rate schedule, etc., but these don't drastically alter the high-level FLOPs estimate. We're ignoring overhead like data loading or activations (which add ~10-20% but are often omitted in rough calcs). GPT-3 used a context length of 2048 tokens, but for total FLOPs, we focus on the full dataset pass.

Step 2: Choose an Appropriate FLOPs Formula for Transformer Training

For large language models like GPT-3, the dominant compute cost is the forward and backward passes through the transformer layers during training. A well-established approximation from AI scaling literature is:

Total training FLOPs ≈ 6 × N × D

• Why 6ND? This comes from breaking down the operations in a dense transformer:
  • The forward pass requires roughly 2ND FLOPs: For each of the D tokens, the model performs matrix multiplications (e.g., self-attention and feed-forward layers) that scale linearly with N parameters. Each parameter is typically "touched" about twice per token (once for weights, once for activations or gradients).
  • The backward pass (for gradient computation) is roughly twice as expensive as the forward pass due to chain rule computations, adding ~4ND FLOPs.
  • Total: ~6ND FLOPs for one full pass over the dataset. (This assumes no model parallelism quirks or sparsity, which GPT-3 didn't heavily use.)
• This formula is a simplification but captures ~90% of the compute for dense models. It's been validated in papers analyzing models like GPT-2/3 and T5. For reference, smaller models (e.g., GPT-2 with 1.5B params and 40B tokens) scale similarly to ~3.6 × 10^20 FLOPs using this.

Note: This is for a single epoch over the dataset. GPT-3 was trained for multiple epochs (effectively more like 1-2 full passes with curriculum learning), but the 6ND formula already accounts for the standard training regime where you iterate until convergence, and D is the total tokens seen.

Step 3: Perform the Calculation

Plug in the values:

• N = 1.75 × 10^11
• D = 3 × 10^11
• 6 × N × D = 6 × (1.75 × 10^11) × (3 × 10^11)
• First, 1.75 × 3 = 5.25
• Then, 5.25 × 10^(11+11) = 5.25 × 10^22
• Finally, 6 × 5.25 × 10^22 = 31.5 × 10^22 = 3.15 × 10^23 FLOPs

Step 4: Consider Uncertainties and Adjustments

• Dataset size variability: If the effective D was closer to 400-500 billion tokens (some estimates suggest this after filtering), the FLOPs would scale to ~4-5 × 10^23. But 300B is a conservative, commonly referenced figure.
• Overheads and efficiencies: Real training includes optimizer steps (e.g., Adam adds ~2x more for momentum), mixed-precision (FP16/BF16 reduces effective FLOPs but not total ops), and distributed training across ~1,000s of GPUs. These might inflate the estimate by 10-50%, but the core model FLOPs dominate.
• Comparison to known benchmarks: This aligns with rough recollections—GPT-3's training is often ballparked at ~10^23 to 10^24 FLOPs, putting it in the "extreme" compute regime at the time (2020). For context, training a 1B-param model on 1B tokens would be ~6 × 10^18 FLOPs, scaling up naturally.
• Limitations: This doesn't include pre-training filtering compute or fine-tuning, just the main language modeling phase. If the dataset was deduplicated or augmented, D could vary, but it doesn't change the order of magnitude.

Final Estimate

The total FLOPs required to train GPT-3 is approximately 3 × 10^23 (or 300 sextillion FLOPs). This is a high-level estimate; exact numbers would require proprietary OpenAI logs, but it's consistent with public analyses. If you have more precise details (e.g., exact token count), the estimate could be refined further.