use burn::tensor::backend::Backend;
use burn::tensor::{Int, Tensor};
fn argtopk3<B: Backend>(x: Tensor<B, 3>, k: usize, dim: usize, device: &B::Device) -> Tensor<B, 3, Int> {
if B::name(device).contains("cubecl") {
x.argtopk(k, dim)
} else {
x.topk_with_indices(k, dim).1
}
}
#[derive(Debug)]
pub struct TopKSelector {
pub topk: usize,
pub block_size: usize,
pub force_local_block: bool,
}
impl TopKSelector {
pub fn new(topk: usize, block_size: usize, force_local_block: bool) -> Self {
Self {
topk,
block_size,
force_local_block,
}
}
pub fn select<B: Backend>(&self, block_scores: Tensor<B, 4>) -> Tensor<B, 4, Int> {
let [batch, h, seq_q, n_blocks] = block_scores.dims();
let topk = self.topk.min(n_blocks);
let device = block_scores.device();
let scores_3d = block_scores
.permute([0, 1, 3, 2]) .reshape::<3, _>([batch * h, n_blocks, seq_q])
.permute([0, 2, 1]);
let indices_3d = if topk >= n_blocks {
Tensor::<B, 1, Int>::arange(0..n_blocks as i64, &device)
.reshape::<3, _>([1, 1, n_blocks])
.repeat_dim(0, batch * h)
.repeat_dim(1, seq_q)
} else if self.force_local_block && seq_q > 0 && n_blocks > 0 && topk > 1 {
let q_pos =
Tensor::<B, 1, Int>::arange(0..seq_q as i64, &device).reshape::<2, _>([seq_q, 1]);
let local_block = q_pos.div_scalar(self.block_size as i64);
let block_idx = Tensor::<B, 1, Int>::arange(0..n_blocks as i64, &device)
.reshape::<2, _>([1, n_blocks]);
let bias = local_block
.equal(block_idx)
.float()
.mul_scalar(1e4)
.unsqueeze::<3>();
argtopk3(scores_3d.add(bias), topk, 2, &device)
} else {
argtopk3(scores_3d, topk, 2, &device)
};
let actual_topk = indices_3d.dims()[2];
indices_3d.reshape::<4, _>([batch, h, seq_q, actual_topk])
}
}