[FSDP2] precompute scale after optimizer.step for dynamic scaling

float8_experimental/float8_dynamic_utils.py

@@ -9,10 +9,7 @@
 
 from typing import Any, Optional, Tuple
 
-import float8_experimental.config as config
-
 import torch
-import torch.nn as nn
 import torch.utils._pytree as pytree
 
 from float8_experimental.float8_tensor import (
@@ -22,7 +19,12 @@
     tensor_already_casted_to_fp8,
     to_fp8_no_autograd,
 )
-from float8_experimental.float8_utils import e4m3_dtype, e5m2_dtype, tensor_to_scale
+from float8_experimental.float8_utils import (
+    amax_to_scale,
+    e4m3_dtype,
+    e5m2_dtype,
+    tensor_to_scale,
+)
 from torch._prims_common import suggest_memory_format
 
 
@@ -85,7 +87,12 @@ def cast_to_float8_e5m2_dynamic_bw(
 
 class WeightWithDynamicFloat8CastTensor(torch.Tensor):
     @staticmethod
-    def __new__(cls, tensor: torch.Tensor, mm_config: ScaledMMConfig):
+    def __new__(
+        cls,
+        tensor: torch.Tensor,
+        mm_config: ScaledMMConfig,
+        amax: Optional[torch.Tensor] = None,
+    ):
         return torch.Tensor._make_wrapper_subclass(
             cls,
             tensor.size(),
@@ -99,9 +106,18 @@ def __new__(cls, tensor: torch.Tensor, mm_config: ScaledMMConfig):
             requires_grad=tensor.requires_grad,
         )
 
-    def __init__(self, tensor: torch.Tensor, mm_config: ScaledMMConfig):
+    def __init__(
+        self,
+        tensor: torch.Tensor,
+        mm_config: ScaledMMConfig,
+        amax: Optional[torch.Tensor] = None,
+    ):
         self._tensor = tensor
         self._mm_config = mm_config
+        # for dynamic scaling
+        # `precompute_float8_amax_for_fsdp` calculates amax
+        # for all float8 parameters after optimizer step
+        self._precomputed_amax = amax
 
     @classmethod
     def __torch_dispatch__(cls, func, types, args, kwargs=None):
@@ -130,20 +146,38 @@ def unwrap(t):
         )
 
     def __tensor_flatten__(self):
-        return ["_tensor"], self._mm_config
+        if self._precomputed_amax:
+            return ["_tensor", "_precomputed_amax"], self._mm_config
+        else:
+            return ["_tensor"], self._mm_config
 
     @staticmethod
     def __tensor_unflatten__(inner_tensors, flatten_spec, outer_size, outer_stride):
         mm_config = flatten_spec
-        return WeightWithDynamicFloat8CastTensor(inner_tensors["_tensor"], mm_config)
+        return WeightWithDynamicFloat8CastTensor(
+            inner_tensors["_tensor"],
+            mm_config,
+            getattr(inner_tensors, "_precomputed_amax", None),
+        )
 
     def __repr__(self):
         return f"WeightWithDynamicFloat8CastTensor(tensor={self._tensor}, mm_config={self._mm_config})"
 
     def fsdp_pre_all_gather(self, mesh):
-        float8_tensor = cast_to_float8_e4m3_dynamic(
-            self._tensor, self._mm_config, reduce_amax=True
-        )
+        if self._precomputed_amax is not None:
+            scale = amax_to_scale(
+                self._precomputed_amax,
+                torch.float8_e4m3fn,
+                self._precomputed_amax.dtype,
+                clamp_amax=False,
+            )
+            float8_tensor = Float8Tensor.to_float8(
+                self._tensor, scale, torch.float8_e4m3fn, mm_config=self._mm_config
+            )
+        else:
+            float8_tensor = cast_to_float8_e4m3_dynamic(
+                self._tensor, self._mm_config, reduce_amax=True
+            )
         return (float8_tensor._data,), (float8_tensor._scale,)
 
     def fsdp_post_all_gather(

float8_experimental/float8_linear_utils.py

@@ -3,16 +3,13 @@
 #
 # This source code is licensed under the BSD 3-Clause license found in the
 # LICENSE file in the root directory of this source tree.
-import copy
 import logging
-from enum import auto, Enum
-from typing import Callable, List, Optional, Type, Union
+from typing import Callable, List, Optional
 
 import torch
 import torch.distributed as dist
 import torch.nn as nn
 from float8_experimental.float8_linear import Float8Linear, TensorScalingType
-
 from float8_experimental.float8_utils import (
     amax_history_to_scale_stack,
     e4m3_dtype,

float8_experimental/float8_utils.py

@@ -34,17 +34,22 @@
 
 @torch.no_grad()
 def amax_to_scale(
-    amax: torch.Tensor, float8_dtype: torch.dtype, orig_dtype: torch.dtype
+    amax: torch.Tensor,
+    float8_dtype: torch.dtype,
+    orig_dtype: torch.dtype,
+    clamp_amax: bool = True,
 ):
     """Converts the amax value of a tensor to the fp8 scale.
     Args:
         amax: The amax value of the tensor.
         float8_dtype: The float8 dtype.
         orig_dtype: The original dtype of the tensor.
+        clamp_amax: default is True. False for FSDP fp8 all-gather since FSDP applied `torch.clamp` during pre-compute after optimizer.step
     """
     scale = torch.empty_like(amax, dtype=torch.float32)
     if float8_dtype in FP8_TYPES:
-        res = torch.finfo(float8_dtype).max / torch.clamp(amax, min=EPS)
+        amax = torch.clamp(amax, min=EPS) if clamp_amax else amax
+        res = torch.finfo(float8_dtype).max / amax
     else:
         raise ValueError(f"Unsupported float8_dtype: {float8_dtype}")
 

float8_experimental/fsdp_utils.py

@@ -0,0 +1,58 @@
+import math
+import warnings
+from typing import List
+
+import torch
+import torch.nn as nn
+from float8_experimental.float8_dynamic_utils import WeightWithDynamicFloat8CastTensor
+from float8_experimental.float8_linear import Float8Linear
+from float8_experimental.float8_linear_utils import linear_requires_sync
+from float8_experimental.float8_utils import EPS
+
+
+def precompute_float8_amax_for_fsdp(module: nn.Module) -> None:
+    """
+    Calculate amax for all float8 parameters after optimizer step
+    It performs a single all-reduce instead of many all-reduces for each parameter
+    Exmaple usage:
+        model(input).sum().backward()
+        optim.step()
+        precompute_float8_amax_for_fsdp(model)
+    """
+    from torch.distributed._tensor import DTensor
+
+    if any(
+        isinstance(m, Float8Linear)
+        and linear_requires_sync(
+            m.scaling_type_x, m.scaling_type_w, m.scaling_type_dL_dY
+        )
+        for m in module.modules()
+    ):
+        raise NotImplementedError("Only supports delayed scaling")
+    float8_linears: List[Float8Linear] = [
+        m
+        for m in module.modules()
+        if isinstance(m, Float8Linear)
+        and isinstance(m.weight, DTensor)
+        and isinstance(m.weight._local_tensor, WeightWithDynamicFloat8CastTensor)
+    ]
+    weights: List[DTensor] = [float8_linear.weight for float8_linear in float8_linears]
+
+    def compute_amaxes(weights: List[DTensor]):
+        # inf-norm is equivalent to max(abs(w))
+        max_weights = torch._foreach_norm(weights, ord=math.inf)  # Partial
+        amax_tensor = torch.vstack(max_weights)  # Partial
+        # clamp is dispatched through DTensor
+        # it will issue a single all-reduce
+        amax_tensor = torch.clamp(amax_tensor, EPS)  # Replicate
+        amaxes = torch.split(amax_tensor, 1)  # Replicate
+        return amaxes
+
+    if weights:
+        amaxes = compute_amaxes(weights)
+        for amax, float8_linear in zip(amaxes, float8_linears):
+            float8_linear.weight._local_tensor._precomputed_amax = amax._local_tensor
+    else:
+        warnings.warn(
+            "Calling precompute_float8_weights without any weights using FSDP fp8 all-gather!"
+        )

test/test_fsdp2/test_fsdp2_common.py

@@ -1,12 +1,12 @@
 import contextlib
-from typing import List, Type
+from typing import List
 
 import float8_experimental.config as config
 
 import torch
 import torch.distributed as dist
 import torch.nn as nn
-from float8_experimental.float8_linear import Float8Linear
+from float8_experimental.fsdp_utils import precompute_float8_amax_for_fsdp
 
 
 def check_parity_no_mp(
@@ -16,6 +16,7 @@ def check_parity_no_mp(
     fsdp_model: nn.Module,
     fsdp_optim: torch.optim.Optimizer,
     local_inp: torch.Tensor,
+    precompute: bool = False,
 ):
     for iter_idx in range(10):
         losses: List[torch.Tensor] = []
@@ -29,6 +30,8 @@ def check_parity_no_mp(
                     param.grad.div_(dist.get_world_size())
             # TODO(future): add amax syncing once delayed scaling is supported
             optim.step()
+            if model is fsdp_model and precompute:
+                precompute_float8_amax_for_fsdp(model)
         test_cls.assertEqual(losses[0], losses[1])
 
 

test/test_fsdp2/test_fsdp2_eager.py

@@ -1,5 +1,4 @@
 import copy
-import itertools
 import threading
 import unittest
 from typing import Any, List
@@ -9,7 +8,7 @@
 import torch.distributed as dist
 import torch.nn as nn
 from float8_experimental.float8_dynamic_utils import WeightWithDynamicFloat8CastTensor
-from float8_experimental.float8_linear import Float8Linear, TensorScalingType
+from float8_experimental.float8_linear import TensorScalingType
 from float8_experimental.float8_linear_utils import swap_linear_with_float8_linear
 from test_fsdp2_common import (
     check_parity_bf16_mp,
@@ -87,10 +86,21 @@ def world_size(self) -> int:
 
     @skip_if_lt_x_gpu(2)
     def test_transformer_parity_dynamic(self):
-        for enable_fsdp_fp8_all_gather in [False, True]:
-            self._test_transformer_parity_dynamic(enable_fsdp_fp8_all_gather)
+        self.run_subtests(
+            {
+                "enable_fsdp_fp8_all_gather": [False, True],
+                "precompute": [False, True],
+            },
+            self._test_transformer_parity_dynamic,
+        )
 
-    def _test_transformer_parity_dynamic(self, enable_fsdp_fp8_all_gather: bool):
+    def _test_transformer_parity_dynamic(
+        self,
+        enable_fsdp_fp8_all_gather: bool,
+        precompute: bool,
+    ):
+        if not enable_fsdp_fp8_all_gather and precompute:
+            return
         # NOTE: Weight-tying does not compose with fp8 all-gather because the
         # embedding weight and output linear weight are tied but only the
         # latter uses fp8 compute. With fp8 all-gather, FSDP would pre-cast to
@@ -110,7 +120,9 @@ def _test_transformer_parity_dynamic(self, enable_fsdp_fp8_all_gather: bool):
         local_inp = torch.randint(
             0, ref_module.tok_embeddings.weight.size(0), (16, 16), device="cuda"
         )
-        check_parity_no_mp(self, ref_module, ref_optim, module, optim, local_inp)
+        check_parity_no_mp(
+            self, ref_module, ref_optim, module, optim, local_inp, precompute
+        )
 
     @skip_if_lt_x_gpu(2)
     def test_transformer_memory(self):