Typos

.gitattributes

@@ -18,7 +18,6 @@
 *.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
 *.pb filter=lfs diff=lfs merge=lfs -text
-*.pdf filter=lfs diff=lfs merge=lfs -text
 *.pickle filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text

The_Ultra-Scale_Playbook_Training_LLMs_on_GPU_Clusters.pdf

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:274a19a2577ed220cd3a102b4469c44310e4a7c8e8f8ebc36842d907cb51e127
-size 14059172

dist/bibliography.bib

@@ -488,7 +488,7 @@ url = {https://github.com/meta-llama/llama3/blob/main/MODEL_CARD.md}
 @software{torchao,
   title = {torchao: PyTorch native quantization and sparsity for training and inference},
   author = {torchao maintainers and contributors},
-  url = {https://github.com/pytorch/ao},
+  url = {https://github.com/pytorch/torchao},
   license = {BSD-3-Clause},
   month = oct,
   year = {2024}

dist/distill.bundle.js

@@ -2146,7 +2146,7 @@ function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
   function bylineTemplate(frontMatter) {
     return "\n    <div class=\"byline grid\">\n      <div>\n          <h3>Authors</h3>\n          <div>\n              ".concat(frontMatter.authors.map(function (author, i) {
       return "\n              <span class=\"author\">\n        ".concat(author.personalURL ? "\n          <a class=\"name\" href=\"".concat(author.personalURL, "\">").concat(author.name) + (i + 1 < frontMatter.authors.length ? "," : "") + "</a>" : "\n          <span class=\"name\">".concat(author.name) + (i + 1 < frontMatter.authors.length ? "," : "") + "</span>", "\n      </span>\n              ");
-    }).join(''), "\n          </div>\n      </div>\n      <div >\n          <h3>Affiliation</h3>\n          <div><a href=\"https://huggingface.co/\">Hugging Face</a>\n          </div>\n      </div>\n      <div >\n          <h3>Published</h3>\n          <div>Feb 19, 2025</div>\n      </div>\n    </div>\n    <div class=\"side pdf-download\">\n      <a href=\"https://huggingface.co/spaces/nanotron/ultrascale-playbook/resolve/main/The_Ultra-Scale_Playbook_Training_LLMs_on_GPU_Clusters.pdf\">Download PDF\n      <br>\n      <img style=\"width: 32px;\" src=\"../assets/images/256px-PDF.png\" alt=\"PDF\"></a>\n      \n    </div>\n");
+    }).join(''), "\n          </div>\n      </div>\n      <div >\n          <h3>Affiliation</h3>\n          <div><a href=\"https://huggingface.co/\">Hugging Face</a>\n          </div>\n      </div>\n      <div >\n          <h3>Published</h3>\n          <div>Feb 19, 2025</div>\n      </div>\n    </div>\n");
   }
   var Byline = /*#__PURE__*/function (_HTMLElement4) {
     function Byline() {

dist/index.html

@@ -75,7 +75,7 @@
         <p>
           Thousands of GPUs humming in perfect harmony. That's what it takes to train today's most powerful AI models – a symphony of computing power that until recently was the exclusive domain of elite research labs. Open source has transformed this landscape, but not completely. Yes, you can download the latest <a href="https://huggingface.co/meta-llama">Llama</a> or <a href="https://huggingface.co/deepseek-ai">DeepSeek</a> models. Yes, you can read their <a href="https://ai.meta.com/research/publications/the-llama-3-herd-of-models/">technical</a> and <a href="https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf">experiment</a> reports. But the most challenging part – the training code, the knowledge and technics necessary to coordinate GPUs to train these massive systems – remains shrouded in complexity and spread around a series of disconnected papers and often private codebases.
           </p>
-          <aside>Reading time: 2-4 days. <br>For the best reading experience, we recommend not using a mobile phone.</aside>
+          <aside>Reading time: 2-4 days. For the best reading experience, we recommend not using a mobile phone.</aside>
           <p>
             This open-source book is here to changes that. Starting from the basics, we'll walk you through the knowledge necessary to scale the training of large language models from one GPU to tens, hundreds and even thousands of GPUs, illustrating theory with practical code examples and reproducible benchmarks.
         </p>
@@ -361,7 +361,7 @@
 
         <h3>Memory usage in Transformers</h3>
 
-        <p>When training a neural network model, one stores several items in memory:</p>
+        <p>When training a neural network model, one store several items in memory:</p>
 
         <ul>
             <li>Model weights</li>
@@ -374,7 +374,7 @@
             <p class="note-box-title">📝 Note</p>
             <div class="note-box-content">
             <p>
-                You would think for a model you could compute the memory requirements exactly but there are a few additional memory occupants that make it hard to be exact:
+                You would think for a model you could compute the memory requirements exactly but there are a few additional memory occupants that makes it hard to be exact:
         <ul>
             <li>CUDA Kernels typically require 1-2 GB of GPU memory, which you can quickly verify by running <code>import torch; torch.ones((1, 1)).to("cuda")</code> and then checking the GPU memory with <code>nvidia-smi</code>.</li>
             <li>Some rest memory usage from buffers, intermediate results and some memory that can’t be used due to fragmentation</li>
@@ -389,7 +389,7 @@
 
         <h4>Profiling the memory usage</h4>
 
-        <p>Using the Pytorch profiler we can understand how memory is allocated throughout training. We can see that memory utilization is not a static thing but varies a lot during training and during a training step:</p>
+        <p>Using the Pytorch profiler we can understand how memory is allocated througho    ut training. We can see that memory utilization is not a static thing but varies a lot during training and during a training step:</p>
 
         <aside>Check out <a target="_self" href="#a1%3A_distributed_training_profiling" class="">A1: Distributed Training Profiling</a> for a walkthrough how to profile your model.</aside>
 
@@ -403,7 +403,7 @@
 
         <p>Clearly the first step looks very different from the subsequent ones, but let’s first have a look at the general anatomy of a step: first the activations increase quickly as we do the forward pass, then during the backward pass the gradients build up and as the backward pass propagates, the stored activations used to compute the gradients are progressively cleared. Finally, we perform the optimization step during which we need all the gradients and then update the optimizer states before we start the next forward pass. </p>
 
-        <p>Why does the first step look different: the activations increase quickly and then plateau for a while. In this first step the torch cache allocator does a lot of preparation preparing memory allocations to speed up the subsequent steps so that they don’t require searching for free memory blocks afterwards (see <a href="https://zdevito.github.io/2022/08/04/cuda-caching-allocator.html">Zach’s blog</a>). After the first step we also see the optimizer states appearing which generally offset the memory usage for further training steps.</p>
+        <p>Why does the first step looks different: the activations increase quickly and then plateau for a while. In this first step the torch cache allocator does a lot of preparation preparing memory allocations to speed up the subsequent steps so that they don’t require searching for free memory blocks afterwards (see <a href="https://zdevito.github.io/2022/08/04/cuda-caching-allocator.html">Zach’s blog</a>). After the first step we also see the optimizer states appearing which generally offset the memory usage for further training steps.</p>
 
         <aside>Ever noticed how sometimes the training succeeds in the first step but then OOMs during the following training steps? This can be explained by the build-up of the optimizer state after the first step.
         </aside>
@@ -518,7 +518,7 @@
 
         <p>For the exact derivation of the numbers, you can follow this original NVIDIA paper on recomputation <d-cite bibtex-key="korthikanti2022recomputation"></d-cite>, it essentially requires you to do some accounting of all the sizes of intermediate activations between each operation in a transformer layer.</p>
 
-        <p>An interesting observation here is that memory usage is not static for a given model; rather, it scales linearly with the batch size and quadratically with the sequence length. This means the activation memory is the part which will blow up when we increase our batch size or train with longer sequences. We can use this equation to look at how memory usage changes for various sequence lengths for example for Llama models (<code>bs=1</code>):</p>
+        <p>An interesting observation here is how the memory is not static for a given model but it scales linearly with both the sequence length and batch size. This means the activation memory is the part which will blow up when we increase our batch size or train with longer sequences. We can use this equation to look at how memory usage changes for various sequence lengths for example for Llama models (<code>bs=1</code>):</p>
 
         <div class="l-body-outset" id="fragment-memusage_activations"></div>
         <!-- <script>
@@ -611,7 +611,7 @@
 
         <p>But if you’ve carefully followed, you probably noticed that the forward/backward passes for each micro-batch can actually be run in parallel. Forward/backward passes are independent from each other, with independent input samples being the only difference. Seems like it’s time to start extending our training to more than one GPU! </p>
 
-        <p>Before that, let's quickly see how we can vizualise computation and communication with a short tour of one of the most useful tool in the distributed training toolbox: the <strong>profiler</strong>. This tool will be extremely useful to understand and validate how communications between GPUs and compute are happening and where bottlenecks are.</p>
+        <p>Before that, let's quickly see how we can vizualise computation and communication with a short tour of one of the most usefull tool in the distributed training toolbox: the <strong>profiler</strong>. This tool will be extremely usefull to understand and validate how communications between GPUs and compute are happening and where bottlenecks are.</p>
 
         <h4>Profiling GPU compute and communication</h4>
 
@@ -1320,6 +1320,7 @@
         <ul>
             <li>for both methods we notice the biggest performance drop when we move from TP=8 to TP=16, because that’s when we move from only communicating within a single node (NVLink), to communicating inter-nodes (EFA)</li>
             <li>the memory savings in activations when using TP with SP helps us fit far bigger batches than TP alone</li>
+            <li>the memory savings in activations when using TP with SP helps us fit far bigger batches than TP alone</li>
         </ul>
 
         <p><strong>We have seen how TP helps us shard activations across several GPUs by splitting the attention and feedforward operations along the hidden dimension and how SP is a natural complement for the remaining operations by splitting along the sequence dimension.</strong></p>
@@ -1363,7 +1364,7 @@
         
         <p>There is one important exception though as we we need to pay particular attention to the <strong>Attention blocks</strong> (haha.. pun intended :D). In the attention module each token needs to access key/value pairs from <strong>all</strong> other sequence tokens or in the case of causal attention at least attends to each previous token.</p>
         
-        <p>Because Context Parallelism splits the inputs along the sequence dimension across GPUs, the attention module will require full communication between GPUs to exchange the necessary key/value data.</p>
+        <p>Because Context Parallelism splits the inputs along the sequence dimension across GPUs, the attention module will requires full communication between GPUs to exchange the necessary key/value data.</p>
         
         <p>That sounds very expensive if we do it naively. Is there a way to do this rather efficiently and fast! Thankfully there is: a core technique to handle this communication of key/value pairs efficiently is called <em>Ring Attention</em>.</p>
         
@@ -1745,7 +1746,7 @@
            </table>
           </div>
 
-        <p>As you can see, ZeRO-3 and PP solve the same challenge but involve different approaches and the choice between both will depend whether you decide to focus communication either on weights or on activations. While they can be combined, it's not often done in practice as doing so requires increasing the global batch size significantly to amortize the communication costs, creating a tradeoff between global batch size, model size, network bandwidth, and training efficiency. If you decide to combine them, ZeRO-3 should be configured to keep the weights in memory during the series of PP micro-batches to minimize as much as possible un-necessary communication overhead.</p>
+        <p>As you can see, ZeRO-3 and PP sove the same challenge but involve different approaches and the choice between both will depend whether you decide to focus communication either on weights or on activations. While they can be combined, it's not often done in practice as doing so requires increasing the global batch size significantly to amortize the communication costs, creating a tradeoff between global batch size, model size, network bandwidth, and training efficiency. If you decide to combine them, ZeRO-3 should be configured to keep the weights in memory during the series of PP micro-batches to minimize as much as possible un-necessary communication overhead.</p>
         
         <p>On the other hand, ZeRO-1 and ZeRO-2, which focus on optimizer states and gradients, can be easily combined with Pipeline Parallelism and are complementary to it. Combining them don't raise any particular new challenge. For instance, the training of DeepSeek-v3 used PP combined with ZeRO-1 (sic).</p>
 
@@ -1793,7 +1794,7 @@
             <li>Tensor Parallelism (and Sequence Parallelism) affects computation throughout the entire model by sharding both weights and activations.</li>
             <li>Context Parallelism primarily impacts attention layers since that's where cross-sequence communication is required, with other layers operating independently on sharded sequences.</li>
             <li>Expert Parallelism primarly affects the MoE layers (which replace standard MLP blocks), leaving attention and other components unchanged</li>
-            <li>Pipeline Parallelism and ZeRO are not especially specific to any sub-module or component with the exception that modules and layers need to be balanced in Pipeline Parallelism, the first and last layers are thus often treated differently due to the additional embedding layers.</li>
+            <li>Pipeline Parallelism and ZeRO are not especially specific to any sub-module or component with the exception that modules and layers need to be balanced in Pipaline Parallelism, the first and last layers are thus often treated differently due to the additional embedding layers.</li>
         </ul>
  
         <table>
@@ -1912,7 +1913,7 @@
     
         <h2>Finding the Best Training Configuration</h2>
 
-        <p>We’ve now covered all the parallelism techniques that are actually used to distribute and train larger models as well as how and why they can be combined together. There remain a general question: which ones should we choose in the end and how to decide on a specific combination?</p>
+        <p>We’ve now covered all the parallelism techniques that are actually used to distribute and training larger models as well as how and why they can be combined together. There remain a general question: which ones should we choose in the end and how to decide on a specific combination?</p>
 
         <p>We touched this a little bit in the previous section but let's now walk in details through a possible decision process, step by step, keeping in mind that you'll always have to run a few experiments to find the definitive optimal setup for your compute cluster given its various physical properties, network bandwidth, GPUs per node, memory per GPU, etc.</p>
         
@@ -2272,7 +2273,7 @@
 
         </ol>
 
-        <p>Let’s talk about one of the most frequent technique we can use in CUDA: optimizing memory access. The global memory in GPUs (the largest memory in our above graph) has a long latency and low bandwidth in comparison to the cache which often creates a major bottleneck for most applications. Efficiently accessing data from global memory can improve performance by a lot.</p>
+        <p>Let’s talk about one of the most frequent technique we can use in CUDA: optimizing memory access. The global memory in GPUs (the largest memory in our above graph) has a long latency and low bandwidth in comparison to the cache which often creates a major bottleneck for most applications. Efficiently accessing data from global memory can improve a lot the performance.</p>
 
         <h4>Memory Coalescing</h4>
         
@@ -2410,7 +2411,7 @@
         
         <p>So it seems warps are stalling waiting for shared memory accesses to return! To solve this issue we can apply a technique called <strong>Thread Coarsening</strong> which involves merging several threads into a single coarsened thread. This will significantly reduce shared memory accesses as each coarsened thread can handle multiple output elements.</p>
 
-        <p>Let's briefly go through a last important consideration when writing or improving custom kernels: <strong>Minimizing Control Divergence</strong>.</p>
+        <p>Let's briefly mentionned a last important consideration when writing or improving custom kernels: <strong>Minimizing Control Divergence</strong>.</p>
 
         <h4>Minimizing Control Divergence</h4>
         
@@ -2571,7 +2572,7 @@
 
         <p>We can see here that bfloat16 maintained the range of float32 over float16 but did this with the cost of sacrificing more precision. In case of float8 the situation is even more dire as e4m3 can represent 7 and e5m2 only 3 number on the interval 1-2.</p>
 
-        <p>A common metric to measure a formats resolution is epsilon: the first representable number after <d-math>1.00</d-math>. We can see that for the float32 format <d-math>10^{-4}</d-math> is an upper bound (it’s actually <d-math>1.19^{-7}</d-math>). For float16 it is ~ <d-math>10^{-3}</d-math> and for bfloat 10x higher still.</p>
+        <p>A common metric to measure a formats resolution is epsilon: the first representable number after <d-math>1.00</d-math>. We can see that for the float32 format <d-math>10^{-4}</d-math> is an upper bound (it’s actually <d-math>1.19^{-7}</d-math>). For float16 it is <d-math>\tilde 10^{-3}</d-math> and for bfloat 10x higher still.</p>
 
         <p>The idea of mixed precision training is to use some of these lower precisions formats while maintaining the performance of full precision training. </p>
 
@@ -3379,7 +3380,7 @@
 
         <p>There are a few finer points in the decision tree that we leave to the reader to explore in the PyTorch guide referenced above.</p>
 
-        <p>Now that we covered the fundamental operations for distributed training and you should now be ready to follow the blog post easily.</p>
+        <p>Now that we covered the fundamental operations for distributed training and when you should should be ready to follow the blog post easily.</p>
         
         <h3>A1: Distributed Training Profiling</h3>
 
@@ -3828,8 +3829,7 @@
                 }
                 if (level === 0)
                     ToC += '<div>' + link + '</div>';
-                else
-                // else if (level === 1)
+                else if (level === 1)
                     ToC += '<li>' + link + '</li>';
             }
 

dist/main.bundle.js

@@ -5544,133 +5544,14 @@ function _loadFragments() {
   return _loadFragments.apply(this, arguments);
 }
 
-;// ./src/syncHFSpacesURLHash.js
-var queryArg = "section";
-function syncHFSpacesURLHash() {
-  // Handle explicit section requests (don't update hash automatically on load)
-  var hasExplicitRequest = handleExplicitSectionRequest();
-
-  // Set up hash change monitoring
-  updateHashBasedOnHashChange();
-
-  // Always set up scroll monitoring to update hash during scrolling
-  setupScrollMonitoring();
-
-  // If no explicit request, we don't update the hash on initial load
-  // The hash will only start updating when the user scrolls
-}
-function handleExplicitSectionRequest() {
-  // Check for section parameter in URL
-  var urlParams = new URLSearchParams(window.location.search);
-  var sectionId = urlParams.get(queryArg);
-
-  // If we have an explicit section request
-  if (sectionId) {
-    var targetElement = document.getElementById(sectionId);
-    if (targetElement) {
-      // Slight delay to ensure the browser doesn't try to do its own scrolling first
-      setTimeout(function () {
-        targetElement.scrollIntoView();
-        history.replaceState(null, null, "#".concat(sectionId));
-      }, 100);
-    }
-    return true;
-  }
-
-  // No explicit section parameter found
-  return false;
-}
-function setupScrollMonitoring() {
-  // Variables to manage throttling
-  var isScrolling = false;
-  var lastKnownScrollPosition = 0;
-  var initialScroll = true;
-
-  // Add the scroll event listener
-  window.addEventListener('scroll', function () {
-    lastKnownScrollPosition = window.scrollY;
-    if (!isScrolling) {
-      window.requestAnimationFrame(function () {
-        // Skip the first scroll event which might be browser's automatic scroll
-        // to a hash on page load
-        if (initialScroll) {
-          initialScroll = false;
-        } else {
-          updateHashBasedOnScroll(lastKnownScrollPosition);
-        }
-        isScrolling = false;
-      });
-    }
-    isScrolling = true;
-  });
-}
-
-// Function to update the URL hash based on scroll position
-function updateHashBasedOnScroll(scrollPosition) {
-  var closestHeading = findClosestHeading(scrollPosition);
-
-  // Update the URL hash if we found a closest element
-  if (closestHeading && closestHeading.id) {
-    // Only update if the hash is different to avoid unnecessary operations
-    if (window.location.hash !== "#".concat(closestHeading.id)) {
-      silentlyUpdateHash(closestHeading.id);
-      postMessageToHFSpaces(closestHeading.id);
-    }
-  }
-}
-
-// Find the closest heading to the current scroll position
-function findClosestHeading(scrollPosition) {
-  // Get only heading elements with IDs that we want to track
-  var headingsWithIds = Array.from(document.querySelectorAll('h1[id], h2[id], h3[id], h4[id], h5[id], h6[id]'));
-
-  // Skip if there are no headings with IDs
-  if (headingsWithIds.length === 0) return null;
-
-  // Find the element closest to the middle of the viewport
-  var closestHeading = null;
-  var closestDistance = Infinity;
-  var viewportMiddle = scrollPosition + window.innerHeight / 2;
-
-  // Iterate through all headings to find the closest one
-  headingsWithIds.forEach(function (heading) {
-    var headingTop = heading.getBoundingClientRect().top + scrollPosition;
-    var distance = Math.abs(headingTop - viewportMiddle);
-    if (distance < closestDistance) {
-      closestDistance = distance;
-      closestHeading = heading;
-    }
-  });
-  return closestHeading;
-}
-
-// Update hash without triggering scroll or other side effects
-function silentlyUpdateHash(id) {
-  history.replaceState(null, null, "#".concat(id));
-}
-function updateHashBasedOnHashChange() {
-  window.addEventListener('hashchange', function () {
-    var elementId = window.location.hash.slice(1);
-    postMessageToHFSpaces(elementId);
-  });
-}
-function postMessageToHFSpaces(elementId) {
-  var parentOrigin = "https://huggingface.co";
-  window.parent.postMessage({
-    queryString: "".concat(queryArg, "=").concat(elementId)
-  }, parentOrigin);
-}
-
 ;// ./src/index.js
 // import { plotClusters } from './clusters'
 
 
-
 document.addEventListener("DOMContentLoaded", function () {
   console.log("DOMContentLoaded");
   loadFragments();
   init_memory_plot();
-  syncHFSpacesURLHash();
 }, {
   once: true
 });

src/bibliography.bib

@@ -488,7 +488,7 @@ url = {https://github.com/meta-llama/llama3/blob/main/MODEL_CARD.md}
 @software{torchao,
   title = {torchao: PyTorch native quantization and sparsity for training and inference},
   author = {torchao maintainers and contributors},
-  url = {https://github.com/pytorch/ao},
+  url = {https://github.com/pytorch/torchao},
   license = {BSD-3-Clause},
   month = oct,
   year = {2024}

src/distill.js

@@ -2105,12 +2105,6 @@ d-appendix > distill-appendix {
           <div>Feb 19, 2025</div>
       </div>
     </div>
-    <div class="side pdf-download">
-      <a href="https://huggingface.co/spaces/nanotron/ultrascale-playbook/resolve/main/The_Ultra-Scale_Playbook_Training_LLMs_on_GPU_Clusters.pdf">Download PDF
-      <br>
-      <img style="width: 32px;" src="../assets/images/256px-PDF.png" alt="PDF"></a>
-      
-    </div>
 `;
   }
 

src/index.html

@@ -75,7 +75,7 @@
         <p>
           Thousands of GPUs humming in perfect harmony. That's what it takes to train today's most powerful AI models – a symphony of computing power that until recently was the exclusive domain of elite research labs. Open source has transformed this landscape, but not completely. Yes, you can download the latest <a href="https://huggingface.co/meta-llama">Llama</a> or <a href="https://huggingface.co/deepseek-ai">DeepSeek</a> models. Yes, you can read their <a href="https://ai.meta.com/research/publications/the-llama-3-herd-of-models/">technical</a> and <a href="https://github.com/deepseek-ai/DeepSeek-R1/blob/main/DeepSeek_R1.pdf">experiment</a> reports. But the most challenging part – the training code, the knowledge and technics necessary to coordinate GPUs to train these massive systems – remains shrouded in complexity and spread around a series of disconnected papers and often private codebases.
           </p>
-          <aside>Reading time: 2-4 days. <br>For the best reading experience, we recommend not using a mobile phone.</aside>
+          <aside>Reading time: 2-4 days. For the best reading experience, we recommend not using a mobile phone.</aside>
           <p>
             This open-source book is here to changes that. Starting from the basics, we'll walk you through the knowledge necessary to scale the training of large language models from one GPU to tens, hundreds and even thousands of GPUs, illustrating theory with practical code examples and reproducible benchmarks.
         </p>
@@ -361,7 +361,7 @@
 
         <h3>Memory usage in Transformers</h3>
 
-        <p>When training a neural network model, one stores several items in memory:</p>
+        <p>When training a neural network model, one store several items in memory:</p>
 
         <ul>
             <li>Model weights</li>
@@ -374,7 +374,7 @@
             <p class="note-box-title">📝 Note</p>
             <div class="note-box-content">
             <p>
-                You would think for a model you could compute the memory requirements exactly but there are a few additional memory occupants that make it hard to be exact:
+                You would think for a model you could compute the memory requirements exactly but there are a few additional memory occupants that makes it hard to be exact:
         <ul>
             <li>CUDA Kernels typically require 1-2 GB of GPU memory, which you can quickly verify by running <code>import torch; torch.ones((1, 1)).to("cuda")</code> and then checking the GPU memory with <code>nvidia-smi</code>.</li>
             <li>Some rest memory usage from buffers, intermediate results and some memory that can’t be used due to fragmentation</li>
@@ -389,7 +389,7 @@
 
         <h4>Profiling the memory usage</h4>
 
-        <p>Using the Pytorch profiler we can understand how memory is allocated throughout training. We can see that memory utilization is not a static thing but varies a lot during training and during a training step:</p>
+        <p>Using the Pytorch profiler we can understand how memory is allocated througho    ut training. We can see that memory utilization is not a static thing but varies a lot during training and during a training step:</p>
 
         <aside>Check out <a target="_self" href="#a1%3A_distributed_training_profiling" class="">A1: Distributed Training Profiling</a> for a walkthrough how to profile your model.</aside>
 
@@ -403,7 +403,7 @@
 
         <p>Clearly the first step looks very different from the subsequent ones, but let’s first have a look at the general anatomy of a step: first the activations increase quickly as we do the forward pass, then during the backward pass the gradients build up and as the backward pass propagates, the stored activations used to compute the gradients are progressively cleared. Finally, we perform the optimization step during which we need all the gradients and then update the optimizer states before we start the next forward pass. </p>
 
-        <p>Why does the first step look different: the activations increase quickly and then plateau for a while. In this first step the torch cache allocator does a lot of preparation preparing memory allocations to speed up the subsequent steps so that they don’t require searching for free memory blocks afterwards (see <a href="https://zdevito.github.io/2022/08/04/cuda-caching-allocator.html">Zach’s blog</a>). After the first step we also see the optimizer states appearing which generally offset the memory usage for further training steps.</p>
+        <p>Why does the first step looks different: the activations increase quickly and then plateau for a while. In this first step the torch cache allocator does a lot of preparation preparing memory allocations to speed up the subsequent steps so that they don’t require searching for free memory blocks afterwards (see <a href="https://zdevito.github.io/2022/08/04/cuda-caching-allocator.html">Zach’s blog</a>). After the first step we also see the optimizer states appearing which generally offset the memory usage for further training steps.</p>
 
         <aside>Ever noticed how sometimes the training succeeds in the first step but then OOMs during the following training steps? This can be explained by the build-up of the optimizer state after the first step.
         </aside>
@@ -518,7 +518,7 @@
 
         <p>For the exact derivation of the numbers, you can follow this original NVIDIA paper on recomputation <d-cite bibtex-key="korthikanti2022recomputation"></d-cite>, it essentially requires you to do some accounting of all the sizes of intermediate activations between each operation in a transformer layer.</p>
 
-        <p>An interesting observation here is that memory usage is not static for a given model; rather, it scales linearly with the batch size and quadratically with the sequence length. This means the activation memory is the part which will blow up when we increase our batch size or train with longer sequences. We can use this equation to look at how memory usage changes for various sequence lengths for example for Llama models (<code>bs=1</code>):</p>
+        <p>An interesting observation here is how the memory is not static for a given model but it scales linearly with both the sequence length and batch size. This means the activation memory is the part which will blow up when we increase our batch size or train with longer sequences. We can use this equation to look at how memory usage changes for various sequence lengths for example for Llama models (<code>bs=1</code>):</p>
 
         <div class="l-body-outset" id="fragment-memusage_activations"></div>
         <!-- <script>
@@ -611,7 +611,7 @@
 
         <p>But if you’ve carefully followed, you probably noticed that the forward/backward passes for each micro-batch can actually be run in parallel. Forward/backward passes are independent from each other, with independent input samples being the only difference. Seems like it’s time to start extending our training to more than one GPU! </p>
 
-        <p>Before that, let's quickly see how we can vizualise computation and communication with a short tour of one of the most useful tool in the distributed training toolbox: the <strong>profiler</strong>. This tool will be extremely useful to understand and validate how communications between GPUs and compute are happening and where bottlenecks are.</p>
+        <p>Before that, let's quickly see how we can vizualise computation and communication with a short tour of one of the most usefull tool in the distributed training toolbox: the <strong>profiler</strong>. This tool will be extremely usefull to understand and validate how communications between GPUs and compute are happening and where bottlenecks are.</p>
 
         <h4>Profiling GPU compute and communication</h4>
 
@@ -1320,6 +1320,7 @@
         <ul>
             <li>for both methods we notice the biggest performance drop when we move from TP=8 to TP=16, because that’s when we move from only communicating within a single node (NVLink), to communicating inter-nodes (EFA)</li>
             <li>the memory savings in activations when using TP with SP helps us fit far bigger batches than TP alone</li>
+            <li>the memory savings in activations when using TP with SP helps us fit far bigger batches than TP alone</li>
         </ul>
 
         <p><strong>We have seen how TP helps us shard activations across several GPUs by splitting the attention and feedforward operations along the hidden dimension and how SP is a natural complement for the remaining operations by splitting along the sequence dimension.</strong></p>
@@ -1363,7 +1364,7 @@
         
         <p>There is one important exception though as we we need to pay particular attention to the <strong>Attention blocks</strong> (haha.. pun intended :D). In the attention module each token needs to access key/value pairs from <strong>all</strong> other sequence tokens or in the case of causal attention at least attends to each previous token.</p>
         
-        <p>Because Context Parallelism splits the inputs along the sequence dimension across GPUs, the attention module will require full communication between GPUs to exchange the necessary key/value data.</p>
+        <p>Because Context Parallelism splits the inputs along the sequence dimension across GPUs, the attention module will requires full communication between GPUs to exchange the necessary key/value data.</p>
         
         <p>That sounds very expensive if we do it naively. Is there a way to do this rather efficiently and fast! Thankfully there is: a core technique to handle this communication of key/value pairs efficiently is called <em>Ring Attention</em>.</p>
         
@@ -1745,7 +1746,7 @@
            </table>
           </div>
 
-        <p>As you can see, ZeRO-3 and PP solve the same challenge but involve different approaches and the choice between both will depend whether you decide to focus communication either on weights or on activations. While they can be combined, it's not often done in practice as doing so requires increasing the global batch size significantly to amortize the communication costs, creating a tradeoff between global batch size, model size, network bandwidth, and training efficiency. If you decide to combine them, ZeRO-3 should be configured to keep the weights in memory during the series of PP micro-batches to minimize as much as possible un-necessary communication overhead.</p>
+        <p>As you can see, ZeRO-3 and PP sove the same challenge but involve different approaches and the choice between both will depend whether you decide to focus communication either on weights or on activations. While they can be combined, it's not often done in practice as doing so requires increasing the global batch size significantly to amortize the communication costs, creating a tradeoff between global batch size, model size, network bandwidth, and training efficiency. If you decide to combine them, ZeRO-3 should be configured to keep the weights in memory during the series of PP micro-batches to minimize as much as possible un-necessary communication overhead.</p>
         
         <p>On the other hand, ZeRO-1 and ZeRO-2, which focus on optimizer states and gradients, can be easily combined with Pipeline Parallelism and are complementary to it. Combining them don't raise any particular new challenge. For instance, the training of DeepSeek-v3 used PP combined with ZeRO-1 (sic).</p>
 
@@ -1793,7 +1794,7 @@
             <li>Tensor Parallelism (and Sequence Parallelism) affects computation throughout the entire model by sharding both weights and activations.</li>
             <li>Context Parallelism primarily impacts attention layers since that's where cross-sequence communication is required, with other layers operating independently on sharded sequences.</li>
             <li>Expert Parallelism primarly affects the MoE layers (which replace standard MLP blocks), leaving attention and other components unchanged</li>
-            <li>Pipeline Parallelism and ZeRO are not especially specific to any sub-module or component with the exception that modules and layers need to be balanced in Pipeline Parallelism, the first and last layers are thus often treated differently due to the additional embedding layers.</li>
+            <li>Pipeline Parallelism and ZeRO are not especially specific to any sub-module or component with the exception that modules and layers need to be balanced in Pipaline Parallelism, the first and last layers are thus often treated differently due to the additional embedding layers.</li>
         </ul>
  
         <table>
@@ -1912,7 +1913,7 @@
     
         <h2>Finding the Best Training Configuration</h2>
 
-        <p>We’ve now covered all the parallelism techniques that are actually used to distribute and train larger models as well as how and why they can be combined together. There remain a general question: which ones should we choose in the end and how to decide on a specific combination?</p>
+        <p>We’ve now covered all the parallelism techniques that are actually used to distribute and training larger models as well as how and why they can be combined together. There remain a general question: which ones should we choose in the end and how to decide on a specific combination?</p>
 
         <p>We touched this a little bit in the previous section but let's now walk in details through a possible decision process, step by step, keeping in mind that you'll always have to run a few experiments to find the definitive optimal setup for your compute cluster given its various physical properties, network bandwidth, GPUs per node, memory per GPU, etc.</p>
         
@@ -2272,7 +2273,7 @@
 
         </ol>
 
-        <p>Let’s talk about one of the most frequent technique we can use in CUDA: optimizing memory access. The global memory in GPUs (the largest memory in our above graph) has a long latency and low bandwidth in comparison to the cache which often creates a major bottleneck for most applications. Efficiently accessing data from global memory can improve performance by a lot.</p>
+        <p>Let’s talk about one of the most frequent technique we can use in CUDA: optimizing memory access. The global memory in GPUs (the largest memory in our above graph) has a long latency and low bandwidth in comparison to the cache which often creates a major bottleneck for most applications. Efficiently accessing data from global memory can improve a lot the performance.</p>
 
         <h4>Memory Coalescing</h4>
         
@@ -2410,7 +2411,7 @@
         
         <p>So it seems warps are stalling waiting for shared memory accesses to return! To solve this issue we can apply a technique called <strong>Thread Coarsening</strong> which involves merging several threads into a single coarsened thread. This will significantly reduce shared memory accesses as each coarsened thread can handle multiple output elements.</p>
 
-        <p>Let's briefly go through a last important consideration when writing or improving custom kernels: <strong>Minimizing Control Divergence</strong>.</p>
+        <p>Let's briefly mentionned a last important consideration when writing or improving custom kernels: <strong>Minimizing Control Divergence</strong>.</p>
 
         <h4>Minimizing Control Divergence</h4>
         
@@ -2571,7 +2572,7 @@
 
         <p>We can see here that bfloat16 maintained the range of float32 over float16 but did this with the cost of sacrificing more precision. In case of float8 the situation is even more dire as e4m3 can represent 7 and e5m2 only 3 number on the interval 1-2.</p>
 
-        <p>A common metric to measure a formats resolution is epsilon: the first representable number after <d-math>1.00</d-math>. We can see that for the float32 format <d-math>10^{-4}</d-math> is an upper bound (it’s actually <d-math>1.19^{-7}</d-math>). For float16 it is ~ <d-math>10^{-3}</d-math> and for bfloat 10x higher still.</p>
+        <p>A common metric to measure a formats resolution is epsilon: the first representable number after <d-math>1.00</d-math>. We can see that for the float32 format <d-math>10^{-4}</d-math> is an upper bound (it’s actually <d-math>1.19^{-7}</d-math>). For float16 it is <d-math>\tilde 10^{-3}</d-math> and for bfloat 10x higher still.</p>
 
         <p>The idea of mixed precision training is to use some of these lower precisions formats while maintaining the performance of full precision training. </p>
 
@@ -3379,7 +3380,7 @@
 
         <p>There are a few finer points in the decision tree that we leave to the reader to explore in the PyTorch guide referenced above.</p>
 
-        <p>Now that we covered the fundamental operations for distributed training and you should now be ready to follow the blog post easily.</p>
+        <p>Now that we covered the fundamental operations for distributed training and when you should should be ready to follow the blog post easily.</p>
         
         <h3>A1: Distributed Training Profiling</h3>
 
@@ -3828,8 +3829,7 @@
                 }
                 if (level === 0)
                     ToC += '<div>' + link + '</div>';
-                else
-                // else if (level === 1)
+                else if (level === 1)
                     ToC += '<li>' + link + '</li>';
             }
 

src/index.js

@@ -1,11 +1,9 @@
 // import { plotClusters } from './clusters'
 import { init_memory_plot } from './memory'
 import { loadFragments } from './fragmentLoader'
-import { syncHFSpacesURLHash } from './syncHFSpacesURLHash'
 
 document.addEventListener("DOMContentLoaded", () => {
     console.log("DOMContentLoaded");
     loadFragments();
     init_memory_plot();
-    syncHFSpacesURLHash();
 }, { once: true });

src/syncHFSpacesURLHash.js

@@ -1,124 +0,0 @@
-const queryArg = "section";
-
-function syncHFSpacesURLHash() {
-  // Handle explicit section requests (don't update hash automatically on load)
-  const hasExplicitRequest = handleExplicitSectionRequest();
-  
-  // Set up hash change monitoring
-  updateHashBasedOnHashChange();
-  
-  // Always set up scroll monitoring to update hash during scrolling
-  setupScrollMonitoring();
-  
-  // If no explicit request, we don't update the hash on initial load
-  // The hash will only start updating when the user scrolls
-}
-
-function handleExplicitSectionRequest() {
-  // Check for section parameter in URL
-  const urlParams = new URLSearchParams(window.location.search);
-  const sectionId = urlParams.get(queryArg);
-  
-  // If we have an explicit section request
-  if (sectionId) {
-    const targetElement = document.getElementById(sectionId);
-    if (targetElement) {
-      // Slight delay to ensure the browser doesn't try to do its own scrolling first
-      setTimeout(() => {
-        targetElement.scrollIntoView();
-        history.replaceState(null, null, `#${sectionId}`);
-      }, 100);
-    }
-    return true;
-  }
-  
-  // No explicit section parameter found
-  return false;
-}
-
-function setupScrollMonitoring() {
-  // Variables to manage throttling
-  let isScrolling = false;
-  let lastKnownScrollPosition = 0;
-  let initialScroll = true;
-  
-  // Add the scroll event listener
-  window.addEventListener('scroll', function() {
-    lastKnownScrollPosition = window.scrollY;
-    
-    if (!isScrolling) {
-      window.requestAnimationFrame(function() {
-        // Skip the first scroll event which might be browser's automatic scroll
-        // to a hash on page load
-        if (initialScroll) {
-          initialScroll = false;
-        } else {
-          updateHashBasedOnScroll(lastKnownScrollPosition);
-        }
-        isScrolling = false;
-      });
-    }
-    
-    isScrolling = true;
-  });
-}
-
-// Function to update the URL hash based on scroll position
-function updateHashBasedOnScroll(scrollPosition) {
-  const closestHeading = findClosestHeading(scrollPosition);
-  
-  // Update the URL hash if we found a closest element
-  if (closestHeading && closestHeading.id) {
-    // Only update if the hash is different to avoid unnecessary operations
-    if (window.location.hash !== `#${closestHeading.id}`) {
-      silentlyUpdateHash(closestHeading.id);
-      postMessageToHFSpaces(closestHeading.id);
-    }
-  }
-}
-
-// Find the closest heading to the current scroll position
-function findClosestHeading(scrollPosition) {
-  // Get only heading elements with IDs that we want to track
-  const headingsWithIds = Array.from(document.querySelectorAll('h1[id], h2[id], h3[id], h4[id], h5[id], h6[id]'));
-
-  // Skip if there are no headings with IDs
-  if (headingsWithIds.length === 0) return null;
-
-  // Find the element closest to the middle of the viewport
-  let closestHeading = null;
-  let closestDistance = Infinity;
-  const viewportMiddle = scrollPosition + window.innerHeight / 2;
-  
-  // Iterate through all headings to find the closest one
-  headingsWithIds.forEach(heading => {
-    const headingTop = heading.getBoundingClientRect().top + scrollPosition;
-    const distance = Math.abs(headingTop - viewportMiddle);
-    
-    if (distance < closestDistance) {
-      closestDistance = distance;
-      closestHeading = heading;
-    }
-  });
-  
-  return closestHeading;
-}
-
-// Update hash without triggering scroll or other side effects
-function silentlyUpdateHash(id) {
-  history.replaceState(null, null, `#${id}`);
-}
-
-function updateHashBasedOnHashChange() {
-  window.addEventListener('hashchange', () => {
-    const elementId = window.location.hash.slice(1);
-    postMessageToHFSpaces(elementId);
-  });
-}
-
-function postMessageToHFSpaces(elementId) {
-  const parentOrigin = "https://huggingface.co";
-  window.parent.postMessage({ queryString: `${queryArg}=${elementId}` }, parentOrigin);
-}
-
-export { syncHFSpacesURLHash };