| | |
| | |
| |
|
| | |
| |
|
| | import torch |
| | from torch import autograd |
| | import math |
| |
|
| |
|
| | class TopKBinarizer(autograd.Function): |
| | """ |
| | Top-k Binarizer. |
| | Computes a binary mask M from a real value matrix S such that `M_{i,j} = 1` if and only if `S_{i,j}` |
| | is among the k% highest values of S. |
| | Implementation is inspired from: |
| | https://github.com/yaozhewei/MLPruning |
| | """ |
| |
|
| | @staticmethod |
| | def forward(ctx, inputs: torch.tensor, threshold: float, sigmoid: bool): |
| | """ |
| | Args: |
| | inputs (`torch.FloatTensor`) |
| | The input matrix from which the binarizer computes the binary mask. |
| | threshold (`float`) |
| | The percentage of weights to keep (the rest is pruned). |
| | `threshold` is a float between 0 and 1. |
| | sigmoid (`bool`) |
| | Whether to apply a sigmoid on the threshold |
| | Returns: |
| | mask (`torch.FloatTensor`) |
| | Binary matrix of the same size as `inputs` acting as a mask (1 - the associated weight is |
| | retained, 0 - the associated weight is pruned). |
| | """ |
| | |
| | if sigmoid: |
| | threshold = torch.sigmoid(threshold).item() |
| | ctx.sigmoid = sigmoid |
| | mask = inputs.clone() |
| |
|
| | _, idx = inputs.flatten().sort(descending=True) |
| | j = math.ceil(threshold * inputs.numel()) |
| |
|
| | |
| | flat_out = mask.flatten() |
| | flat_out[idx[j:]] = 0. |
| | flat_out[idx[:j]] = 1. |
| | ctx.save_for_backward(mask) |
| |
|
| | return mask |
| |
|
| | @staticmethod |
| | def backward(ctx, gradOutput): |
| | mask, = ctx.saved_tensors |
| | if ctx.sigmoid: |
| | return gradOutput.clone(), ((gradOutput * mask).sum()).view(-1), None |
| | else: |
| | return gradOutput.clone(), None, None |
| |
|
| |
|
| | class SymQuantizer(torch.autograd.Function): |
| | """ |
| | Symmetric quantization |
| | """ |
| |
|
| | @staticmethod |
| | def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1): |
| | """ |
| | Args: |
| | inputs (`torch.FloatTensor`) |
| | The input which needs to be quantized |
| | num_bits (int, >=4) |
| | Number of bits to use for quantization |
| | min_value/max_value (torch.FloatTensor) |
| | Used for static activation quantization |
| | num_groups (int) |
| | How many groups to partition the quantization into |
| | Returns: |
| | quantized_input (`torch.FloatTensor`) |
| | Quantized input |
| | """ |
| | assert (min_value is None and max_value is None) or (min_value is not None and max_value is not None |
| | and num_groups == 1) |
| | q_range = 2**num_bits |
| | input_shape = input.shape |
| | if min_value is None: |
| | input = input.reshape(num_groups, -1) |
| | max_input = torch.amax(torch.abs(input), dim=-1).view(num_groups, -1) |
| | else: |
| | max_input = torch.max(min_value.abs(), max_value).view(-1) |
| |
|
| | scale = 2 * max_input / q_range |
| | output = (input / scale).round().clamp(-q_range // 2, q_range // 2 - 1) * scale |
| | output = output.reshape(input_shape).contiguous() |
| | return output |
| |
|
| | @staticmethod |
| | def backward(ctx, grad_output): |
| | grad_input = grad_output.clone() |
| | return grad_input, None, None, None, None |
| |
|
| |
|
| | class AsymQuantizer(torch.autograd.Function): |
| | """ |
| | Asymmetric quantization |
| | """ |
| |
|
| | @staticmethod |
| | def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1): |
| | """ |
| | Args: |
| | inputs (`torch.FloatTensor`) |
| | The input which needs to be quantized |
| | num_bits (int, >=4) |
| | Number of bits to use for quantization |
| | min_value/max_value (torch.FloatTensor) |
| | Used for static activation quantization |
| | num_groups (int) |
| | How many groups to partition the quantization into |
| | Returns: |
| | quantized_input (`torch.FloatTensor`) |
| | Quantized input |
| | """ |
| |
|
| | assert (min_value is None and max_value is None) or (min_value is not None and max_value is not None |
| | and num_groups == 1) |
| | q_range = 2**num_bits |
| | input_shape = input.shape |
| | if min_value is None: |
| | input = input.reshape(num_groups, -1) |
| | min_value = input.amin(dim=-1, keepdim=True) |
| | max_value = input.amax(dim=-1, keepdim=True) |
| |
|
| | scale = (max_value - min_value) / q_range |
| | zero_point = (min_value / scale).round() * scale |
| |
|
| | output = ((input - zero_point) / scale).round().clamp(0, q_range - 1) * scale + zero_point |
| | output = output.reshape(input_shape).contiguous() |
| | return output |
| |
|
| | @staticmethod |
| | def backward(ctx, grad_output): |
| | grad_input = grad_output.clone() |
| | return grad_input, None, None, None, None |
| |
|
| |
|
| | class TernaryQuantizer(torch.autograd.Function): |
| | """ |
| | Ternary quantization |
| | """ |
| |
|
| | @staticmethod |
| | def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1): |
| | """ |
| | Args: |
| | inputs (`torch.FloatTensor`) |
| | The input which needs to be quantized |
| | num_bits (int) |
| | Dummy variable |
| | min_value/max_value (torch.FloatTensor) |
| | Used for static activation quantization; for now they are dummy variable |
| | num_groups (int) |
| | How many groups to partition the quantization into |
| | Returns: |
| | quantized_input (`torch.FloatTensor`) |
| | Quantized input |
| | """ |
| |
|
| | assert (min_value is None and max_value is None) |
| | input_flat = input.reshape(num_groups, -1) |
| | n = input_flat.shape[1] |
| | m = input_flat.norm(p=1, dim=1).div(n) |
| | thres = (0.7 * m).view(-1, 1) |
| | pos = (input_flat > thres).type(input.type()) |
| | neg = (input_flat < -thres).type(input.type()) |
| | mask = (input_flat.abs() > thres).type(input.type()) |
| | alpha = ((mask * input_flat).abs().sum(dim=1) / mask.sum(dim=1)).view(-1, 1) |
| | output = alpha * pos - alpha * neg |
| | output = output.reshape(input.shape).contiguous() |
| | return output |
| |
|
| | @staticmethod |
| | def backward(ctx, grad_output): |
| | grad_input = grad_output.clone() |
| | return grad_input, None, None, None, None |
| |
|
| |
|
| | class BinaryQuantizer(torch.autograd.Function): |
| | """ |
| | Binary quantization |
| | """ |
| |
|
| | @staticmethod |
| | def forward(ctx, input, num_bits, min_value=None, max_value=None, num_groups=1): |
| | """ |
| | Args: |
| | inputs (`torch.FloatTensor`) |
| | The input which needs to be quantized |
| | num_bits (int) |
| | Dummy variable |
| | min_value/max_value (torch.FloatTensor) |
| | Used for static activation quantization; for now they are dummy variable |
| | num_groups (int) |
| | How many groups to partition the quantization into |
| | Returns: |
| | quantized_input (`torch.FloatTensor`) |
| | Quantized input |
| | """ |
| |
|
| | assert (min_value is None and max_value is None) |
| | input_flat = input.reshape(num_groups, -1) |
| | n = input_flat.shape[1] |
| | m = input_flat.norm(p=1, dim=1, keepdim=True).div(n) |
| | output = input_flat.sign().mul(m) |
| | output = output.reshape(input.shape).contiguous() |
| | return output |
| |
|
| | @staticmethod |
| | def backward(ctx, grad_output): |
| | grad_input = grad_output.clone() |
| | return grad_input, None, None, None, None |
| |
|
