use alloc::vec::Vec;
use core::ops::Range;
use burn::{
Tensor,
prelude::Int,
tensor::{
DType,
Device,
},
};
use super::{
LmDecodeKind,
LmDecoderHolder,
LmDecoderModel,
LmDecoderWrapper,
};
use crate::blocks::transformers::{
decoders::stack::DecoderStack,
embedding::RotarySet,
};
pub trait LmDecoderOps {
fn float_dtype(&self) -> DType;
fn rotary(
&self,
seq_len: usize,
device: &Device,
) -> RotarySet;
fn embed(
&self,
tokens: Tensor<2, Int>,
) -> Tensor<3>;
fn logits(
&self,
hidden: Tensor<3>,
) -> Tensor<3>;
}
pub trait LmPlainStackOps: LmDecoderOps {
fn stack(&self) -> &DecoderStack;
fn attention_weights(
&self,
embeds: Tensor<3>,
r_emb: &RotarySet,
layers: &[usize],
rows: Range<usize>,
cols: Range<usize>,
) -> Vec<Tensor<4>> {
self.stack()
.attention_weights(embeds, r_emb, layers, rows, cols)
}
}
impl<K: LmDecodeKind> LmDecoderOps for LmDecoderModel<K> {
fn float_dtype(&self) -> DType {
LmDecoderModel::float_dtype(self)
}
fn rotary(
&self,
seq_len: usize,
device: &Device,
) -> RotarySet {
LmDecoderModel::rotary(self, seq_len, device)
}
fn embed(
&self,
tokens: Tensor<2, Int>,
) -> Tensor<3> {
LmDecoderModel::embed(self, tokens)
}
fn logits(
&self,
hidden: Tensor<3>,
) -> Tensor<3> {
LmDecoderModel::logits(self, hidden)
}
}
impl<K: LmDecodeKind> LmPlainStackOps for LmDecoderModel<K> {
fn stack(&self) -> &DecoderStack {
&self.stack
}
}
impl<W: LmDecoderHolder> LmDecoderOps for W {
fn float_dtype(&self) -> DType {
self.lm().float_dtype()
}
fn rotary(
&self,
seq_len: usize,
device: &Device,
) -> RotarySet {
self.lm().rotary(seq_len, device)
}
fn embed(
&self,
tokens: Tensor<2, Int>,
) -> Tensor<3> {
self.lm().embed(tokens)
}
fn logits(
&self,
hidden: Tensor<3>,
) -> Tensor<3> {
self.lm().logits(hidden)
}
}
impl<W: LmDecoderWrapper> LmPlainStackOps for W {
fn stack(&self) -> &DecoderStack {
&self.lm().stack
}
}