Cannot reshape a block-quantized tensor when the reshape req

Error message

Cannot reshape a block-quantized tensor when the reshape requires recomputing the buffer.

What it means

Some reshapes require materializing a new contiguous buffer; for block-quantized tensors with multiple scale blocks, the original block boundaries no longer align with the new layout, so scales would have to be recomputed. Since this is not implemented, q_reshape panics instead of silently corrupting the scales.

Source

Thrown at crates/burn-cubecl/src/ops/base.rs:465

        }
        // Any action to recompute
        (ReshapeAction::Recompute, _) | (_, ReshapeAction::Recompute) => {
            // Rewriting the buffer would have to repack values that share a
            // storage element; a metadata-only reshape leaves the packing alone.
            if !is_unsqueeze
                && matches!(
                    scheme.value,
                    QuantValue::Q4S | QuantValue::Q4F | QuantValue::Q2S | QuantValue::Q2F
                )
            {
                todo!(
                    "Reshape with sub-byte values is not supported when the buffer must be recomputed"
                )
            }

            if scheme.block_size().is_some() && shape_scales.num_elements() > 1 {
                // Original block boundaries no longer align with the layout, would have to be recomputed
                unimplemented!(
                    "Cannot reshape a block-quantized tensor when the reshape requires recomputing the buffer."
                );
            }

            tensor = kernel::into_contiguous(tensor);
            *tensor.meta = Metadata::new(shape, contiguous_strides(&shape_values));

            let qparams = tensor.qparams.as_mut().unwrap();

            let strides = contiguous_strides(&shape_scales);
            qparams.scales.metadata = Metadata::new(shape_scales, strides);
        }
        (ReshapeAction::NoChange, ReshapeAction::NoChange) => {}
    }

    tensor
}

View on GitHub (pinned to d16f7ba2ed)

Solutions

Call tensor.clone().into_contiguous() (dequantize then requantize) before reshaping
Avoid reshaping block-quantized tensors; restructure code so shapes stay fixed across quantized ops
Use non-block (per-tensor) quantization where reshaping is needed
Upgrade burn to check if scale recomputation on reshape was implemented

Example fix

// before
let y = x.transpose(0, 1).reshape([rows, cols]); // block-quant -> panic
// after
let y = x.dequantize().transpose(0, 1).reshape([rows, cols]); // then requantize if needed

Defensive patterns

Strategy: validation

Validate before calling

fn reshape_needs_recompute(tensor_non_contiguous: bool, scheme: &QuantScheme, scales_elems: usize) -> bool {
    tensor_non_contiguous && scheme.block_size().is_some() && scales_elems > 1
}

Type guard

fn reshape_safe(t: &CubeTensor) -> bool {
    t.scheme.block_size().is_none() || t.scales_shape().num_elements() <= 1 || t.is_contiguous()
}

Try / catch

// Guard:
if reshape_safe(&t) { t.reshape(new_shape) } else { t.dequantize().reshape(new_shape) }

Prevention

Make block-quantized tensors contiguous (or dequantize) before reshaping
Avoid reshaping after transposes on quantized tensors
Prefer per-tensor quantization when reshapes are common

When it happens

Trigger: Calling reshape on a block-quantized tensor (block_size set, scales.num_elements() > 1) whose new shape requires the buffer to be recomputed (non-trivial stride change), including sub-byte packed values needing buffer recomputation.

Common situations: Reshaping non-contiguous or transposed quantized tensors; calling ops that internally reshape before kernels requiring contiguity.

Related errors

AI-assisted analysis of tracel-ai/burn@d16f7ba2ed (2026-09-05). Data as JSON: /api/errors/59672cc26b1fd85d. Report an issue: GitHub.