"""NF4 (4-bit NormalFloat) quantization utilities for base model compression. Parallel to fp8_optimization_utils.py — provides quantize/dequantize, monkey-patching, and safetensors loading with NF4 quantization. The NF4 codebook is the set of 16 values that are optimal for normally-distributed weights (as derived in the QLoRA paper). Weights are stored as packed uint8 (two 4-bit indices per byte) with per-block absmax scales. """ import os from typing import List, Optional, Tuple, Union import torch import torch.nn as nn import torch.nn.functional as F import logging from tqdm import tqdm from musubi_tuner.utils.safetensors_utils import MemoryEfficientSafeOpen, TensorWeightAdapter, WeightTransformHooks from musubi_tuner.utils.device_utils import clean_memory_on_device logger = logging.getLogger(__name__) # --------------------------------------------------------------------------- # NF4 codebook (16 values, symmetric around 0, optimal for N(0,1) weights) # --------------------------------------------------------------------------- NF4_CODEBOOK = torch.tensor( [ -1.0, -0.6961928009986877, -0.5250730514526367, -0.39491748809814453, -0.28444138169288635, -0.18477343022823334, -0.09105003625154495, 0.0, 0.07958029955625534, 0.16093020141124725, 0.24611230194568634, 0.33791524171829224, 0.44070982933044434, 0.5626170039176941, 0.7229568362236023, 1.0, ], dtype=torch.float32, ) DEFAULT_NF4_BLOCK_SIZE = 32 # --------------------------------------------------------------------------- # Pack / unpack helpers # --------------------------------------------------------------------------- def pack_uint4(indices: torch.Tensor) -> torch.Tensor: """Pack pairs of 4-bit indices into uint8. ``indices`` must have even length.""" assert indices.numel() % 2 == 0, "Number of elements must be even for uint4 packing" flat = indices.view(-1) high = flat[0::2].to(torch.uint8) low = flat[1::2].to(torch.uint8) return (high << 4) | low def unpack_uint4(packed: torch.Tensor, num_elements: int) -> torch.Tensor: """Unpack uint8 → pairs of 4-bit indices. Returns ``[num_elements]`` uint8.""" flat = packed.view(-1) high = (flat >> 4) & 0x0F low = flat & 0x0F # interleave: [h0, l0, h1, l1, ...] out = torch.stack([high, low], dim=1).view(-1) return out[:num_elements].to(torch.uint8) # --------------------------------------------------------------------------- # Quantize / dequantize # --------------------------------------------------------------------------- def quantize_nf4_block( tensor: torch.Tensor, block_size: int = DEFAULT_NF4_BLOCK_SIZE, ) -> Tuple[torch.Tensor, torch.Tensor]: """Quantize a 2-D weight tensor to NF4 with per-block absmax scaling. Args: tensor: ``[out_features, in_features]`` float weight. block_size: number of elements per quantization block. Returns: packed_weight: ``[out_features, in_features // 2]`` uint8 (two indices per byte). scale: ``[out_features, num_blocks, 1]`` float32 absmax per block. """ assert tensor.ndim == 2, f"Expected 2-D tensor, got {tensor.ndim}-D" out_features, in_features = tensor.shape if in_features % block_size != 0: raise ValueError( f"in_features ({in_features}) must be divisible by block_size ({block_size})" ) num_blocks = in_features // block_size # Reshape to [out, num_blocks, block_size] t = tensor.float().contiguous().view(out_features, num_blocks, block_size) # Per-block absmax scale scale = t.abs().amax(dim=2, keepdim=True).clamp_(min=1e-8) # [out, num_blocks, 1] # Normalize to [-1, 1] normalized = t / scale # [out, num_blocks, block_size] # Find nearest codebook entry using bucketize (O(N) memory, not O(N*16)). # The codebook is sorted, so we compute midpoints between consecutive values # and use bucketize to find which bin each normalized value falls into. codebook = NF4_CODEBOOK.to(normalized.device) # [16] # Midpoints between consecutive codebook values → 15 boundaries midpoints = (codebook[:-1] + codebook[1:]) / 2.0 # [15] flat_norm = normalized.reshape(-1) # [N] indices = torch.bucketize(flat_norm, midpoints) # [N] int64, values in [0, 15] # Reshape indices back and pack indices = indices.view(out_features, in_features) # [out, in] packed = pack_uint4(indices).view(out_features, in_features // 2) return packed, scale.to(torch.float32) def dequantize_nf4_block( packed_weight: torch.Tensor, scale: torch.Tensor, out_features: int, in_features: int, block_size: int = DEFAULT_NF4_BLOCK_SIZE, dtype: torch.dtype = torch.bfloat16, ) -> torch.Tensor: """Dequantize NF4-packed weight back to a dense float tensor. Args: packed_weight: ``[out_features, in_features // 2]`` uint8. scale: ``[out_features, num_blocks, 1]`` float32. out_features, in_features: original weight shape. block_size: must match quantization block size. dtype: output dtype (e.g. bfloat16). Returns: ``[out_features, in_features]`` tensor in *dtype*. """ num_blocks = in_features // block_size codebook = NF4_CODEBOOK.to(scale.device) # [16] indices = unpack_uint4(packed_weight, out_features * in_features) indices = indices.to(scale.device).long() values = codebook[indices] # float32 values = values.view(out_features, num_blocks, block_size) values = values * scale # broadcast [out, num_blocks, 1] values = values.view(out_features, in_features) return values.to(dtype) # --------------------------------------------------------------------------- # State-dict-level quantization (mirrors optimize_state_dict_with_fp8) # --------------------------------------------------------------------------- def optimize_state_dict_with_nf4( state_dict: dict, calc_device: Union[str, torch.device], target_layer_keys: Optional[List[str]] = None, exclude_layer_keys: Optional[List[str]] = None, block_size: int = DEFAULT_NF4_BLOCK_SIZE, move_to_device: bool = False, ) -> dict: """Quantize target Linear weights in *state_dict* to NF4 in-place. For each target ``.weight`` key the dict is updated with: * original key → packed uint8 weight ``[out, in//2]`` * ``.scale_weight`` → per-block scale ``[out, num_blocks, 1]`` * ``.nf4_shape`` → ``torch.tensor([out, in])`` (original shape) """ optimized_count = 0 target_keys_list = [] for key in list(state_dict.keys()): is_target = ( target_layer_keys is None or any(p in key for p in target_layer_keys) ) and key.endswith(".weight") is_excluded = exclude_layer_keys is not None and any( p in key for p in exclude_layer_keys ) if is_target and not is_excluded and isinstance(state_dict[key], torch.Tensor): target_keys_list.append(key) for key in tqdm(target_keys_list, desc="NF4 quantizing"): value = state_dict[key] if value.ndim != 2: continue # skip non-2D (e.g. bias, norm) out_features, in_features = value.shape if in_features % block_size != 0: logger.warning( "Skipping NF4 for %s: in_features=%d not divisible by block_size=%d", key, in_features, block_size, ) continue original_device = value.device original_dtype = value.dtype if calc_device is not None: value = value.to(calc_device) packed, scale = quantize_nf4_block(value, block_size) target_device = calc_device if (calc_device is not None and move_to_device) else original_device state_dict[key] = packed.to(target_device) state_dict[key.replace(".weight", ".scale_weight")] = scale.to( dtype=original_dtype, device=target_device ) state_dict[key.replace(".weight", ".nf4_shape")] = torch.tensor( [out_features, in_features], dtype=torch.int64 ) optimized_count += 1 if calc_device is not None and optimized_count % 10 == 0: clean_memory_on_device(calc_device) logger.info(f"Number of NF4-quantized Linear layers: {optimized_count}") return state_dict def load_safetensors_with_nf4_optimization( model_files: List[str], calc_device: Union[str, torch.device], target_layer_keys: Optional[List[str]] = None, exclude_layer_keys: Optional[List[str]] = None, block_size: int = DEFAULT_NF4_BLOCK_SIZE, move_to_device: bool = False, weight_hook=None, disable_numpy_memmap: bool = False, weight_transform_hooks: Optional[WeightTransformHooks] = None, ) -> dict: """Load safetensors and quantize target layers to NF4. Mirrors ``load_safetensors_with_fp8_optimization``. """ def is_target_key(key): is_target = ( target_layer_keys is None or any(p in key for p in target_layer_keys) ) and key.endswith(".weight") is_excluded = exclude_layer_keys is not None and any( p in key for p in exclude_layer_keys ) return is_target and not is_excluded optimized_count = 0 state_dict: dict = {} for model_file in model_files: with MemoryEfficientSafeOpen(model_file, disable_numpy_memmap=disable_numpy_memmap) as original_f: f = ( TensorWeightAdapter(weight_transform_hooks, original_f) if weight_transform_hooks is not None else original_f ) keys = f.keys() for key in tqdm(keys, desc=f"Loading {os.path.basename(model_file)}", unit="key"): value = f.get_tensor(key) original_device = value.device if weight_hook is not None: value = weight_hook(key, value, keep_on_calc_device=(calc_device is not None)) if not is_target_key(key) or value.ndim != 2: target_device = calc_device if (calc_device is not None and move_to_device) else original_device state_dict[key] = value.to(target_device) continue out_features, in_features = value.shape if in_features % block_size != 0: logger.warning( "Skipping NF4 for %s: in_features=%d not divisible by block_size=%d", key, in_features, block_size, ) target_device = calc_device if (calc_device is not None and move_to_device) else original_device state_dict[key] = value.to(target_device) continue if calc_device is not None: value = value.to(calc_device) original_dtype = value.dtype packed, scale = quantize_nf4_block(value, block_size) target_device = calc_device if (calc_device is not None and move_to_device) else original_device state_dict[key] = packed.to(target_device) state_dict[key.replace(".weight", ".scale_weight")] = scale.to( dtype=original_dtype, device=target_device ) state_dict[key.replace(".weight", ".nf4_shape")] = torch.tensor( [out_features, in_features], dtype=torch.int64 ) optimized_count += 1 if calc_device is not None and optimized_count % 10 == 0: clean_memory_on_device(calc_device) logger.info(f"Number of NF4-quantized Linear layers: {optimized_count}") return state_dict # --------------------------------------------------------------------------- # Monkey-patched forward # --------------------------------------------------------------------------- def nf4_linear_forward_patch(self: nn.Linear, x: torch.Tensor) -> torch.Tensor: """Drop-in replacement forward for NF4-quantized Linear layers.""" w = dequantize_nf4_block( self.weight, self.scale_weight, self.nf4_out_features, self.nf4_in_features, self.nf4_block_size, self.scale_weight.dtype, ) if hasattr(self, "awq_scales"): # Un-scale columns: divide by the AWQ scales that were multiplied before quantization w = w / self.awq_scales.unsqueeze(0) # [1, in] broadcast over [out, in] w = w.to(self.scale_weight.dtype) return F.linear(x, w, self.bias) def apply_nf4_monkey_patch( model: nn.Module, optimized_state_dict: dict, block_size: int = DEFAULT_NF4_BLOCK_SIZE, awq_scales: Optional[dict] = None, ) -> nn.Module: """Register NF4 buffers and replace forward on quantized Linears. Mirrors ``apply_fp8_monkey_patch``. Args: awq_scales: Optional dict mapping module_name -> scale tensor [in_features]. If provided, each patched module gets an ``awq_scales`` buffer for un-scaling during the forward pass. """ # Identify NF4-quantized modules from the state dict shape_keys = [k for k in optimized_state_dict if k.endswith(".nf4_shape")] patched_module_paths: set = set() shape_info: dict = {} scale_shape_info: dict = {} for shape_key in shape_keys: module_path = shape_key.rsplit(".nf4_shape", 1)[0] patched_module_paths.add(module_path) shape_tensor = optimized_state_dict[shape_key] shape_info[module_path] = (int(shape_tensor[0].item()), int(shape_tensor[1].item())) scale_key = module_path + ".scale_weight" scale_shape_info[module_path] = optimized_state_dict[scale_key].shape patched_count = 0 for name, module in model.named_modules(): if name not in patched_module_paths: continue if not isinstance(module, nn.Linear): continue out_f, in_f = shape_info[name] scale_shape = scale_shape_info[name] packed_shape = (out_f, in_f // 2) # Replace weight parameter with a buffer of packed shape so # load_state_dict(assign=True) doesn't complain about shape mismatch. weight_dtype = module.weight.dtype if module.weight.dtype != torch.float32 else torch.uint8 del module.weight module.register_buffer("weight", torch.zeros(packed_shape, dtype=torch.uint8)) # Register buffers so load_state_dict can assign them module.register_buffer("scale_weight", torch.ones(scale_shape, dtype=weight_dtype)) module.register_buffer("nf4_shape", torch.zeros(2, dtype=torch.int64)) # Store metadata as plain attributes module.nf4_out_features = out_f module.nf4_in_features = in_f module.nf4_block_size = block_size module._nf4_quantized = True # Register AWQ scales buffer if available if awq_scales is not None: # AWQ scales are keyed by weight key (e.g. "layer.weight") weight_key = name + ".weight" if weight_key in awq_scales: module.register_buffer( "awq_scales", awq_scales[weight_key].to(dtype=torch.float32), ) # Replace forward def new_forward(self, x): return nf4_linear_forward_patch(self, x) module.forward = new_forward.__get__(module, type(module)) patched_count += 1 logger.info(f"Number of NF4 monkey-patched Linear layers: {patched_count}") return model # --------------------------------------------------------------------------- # Detection helper # --------------------------------------------------------------------------- def is_nf4_module(module: nn.Module) -> bool: """Check whether *module* has been NF4-quantized (attribute-based, not dtype).""" return getattr(module, "_nf4_quantized", False)