use std::fmt::Debug;
use burn::{
Tensor,
module::Module,
prelude::Backend,
};
use dyn_clone::DynClone;
fn row_max<B: Backend>(x: Tensor<B, 3>) -> Tensor<B, 1> {
x.max_dims(&[1, 2]).reshape([-1])
}
pub trait StreamClampPolicy<B: Backend>: Send + Sync + Debug + DynClone {
fn observe(
&mut self,
frames: Tensor<B, 3>,
);
fn reference(
&self,
window: Tensor<B, 3>,
) -> Tensor<B, 1>;
}
dyn_clone::clone_trait_object!(<B: Backend> StreamClampPolicy<B>);
impl<B: Backend> StreamClampPolicy<B> for Box<dyn StreamClampPolicy<B>> {
fn observe(
&mut self,
frames: Tensor<B, 3>,
) {
(**self).observe(frames);
}
fn reference(
&self,
window: Tensor<B, 3>,
) -> Tensor<B, 1> {
(**self).reference(window)
}
}
#[derive(Debug, Default, Clone, Copy)]
pub struct PerWindow;
impl<B: Backend> StreamClampPolicy<B> for PerWindow {
fn observe(
&mut self,
_frames: Tensor<B, 3>,
) {
}
fn reference(
&self,
window: Tensor<B, 3>,
) -> Tensor<B, 1> {
row_max(window)
}
}
#[derive(Module, Debug)]
pub struct RunningMaxClamp<B: Backend> {
seen: Option<Tensor<B, 1>>,
}
impl<B: Backend> Default for RunningMaxClamp<B> {
fn default() -> Self {
Self::new()
}
}
impl<B: Backend> RunningMaxClamp<B> {
pub fn new() -> Self {
Self { seen: None }
}
pub fn seen(&self) -> Option<&Tensor<B, 1>> {
self.seen.as_ref()
}
}
impl<B: Backend> StreamClampPolicy<B> for RunningMaxClamp<B> {
fn observe(
&mut self,
frames: Tensor<B, 3>,
) {
let arriving = row_max(frames);
self.seen = Some(match self.seen.take() {
Some(seen) => seen.max_pair(arriving),
None => arriving,
});
}
fn reference(
&self,
window: Tensor<B, 3>,
) -> Tensor<B, 1> {
let own = row_max(window);
match &self.seen {
Some(seen) => seen.clone().max_pair(own),
None => own,
}
}
}
#[cfg(test)]
mod tests {
use burn::prelude::TensorData;
use super::*;
use crate::{
prelude::TensorElemOpExt,
support::testing::{
CpuBackend,
assert_close_to_vec,
},
};
type B = CpuBackend;
fn frames(values: [f64; 8]) -> Tensor<B, 3> {
Tensor::from_data(
TensorData::new(values.to_vec(), [2, 2, 2]),
&Default::default(),
)
}
fn to_vec(t: Tensor<B, 1>) -> Vec<f64> {
t.into_data_as::<f64>().to_vec().unwrap()
}
#[test]
fn test_per_window_is_each_rows_own_maximum() {
let mut policy = PerWindow;
let window = frames([0.0, -3.0, -1.0, -20.0, 5.0, 4.0, -9.0, 1.0]);
StreamClampPolicy::<B>::observe(&mut policy, frames([99.0; 8]));
assert_close_to_vec(&to_vec(policy.reference(window)), &[0.0, 5.0], 1e-12);
}
#[test]
fn test_max_seen_runs_over_observations() {
let mut policy = RunningMaxClamp::<B>::new();
assert!(policy.seen().is_none());
policy.observe(frames([0.0, -3.0, -1.0, -20.0, 5.0, 4.0, -9.0, 1.0]));
assert_close_to_vec(&to_vec(policy.seen().unwrap().clone()), &[0.0, 5.0], 1e-12);
policy.observe(frames([7.0, -3.0, -1.0, -20.0, -5.0, -4.0, -9.0, -1.0]));
assert_close_to_vec(&to_vec(policy.seen().unwrap().clone()), &[7.0, 5.0], 1e-12);
let quiet = frames([-10.0; 8]);
assert_close_to_vec(&to_vec(policy.reference(quiet)), &[7.0, 5.0], 1e-12);
let loud = frames([-10.0, -10.0, -10.0, -10.0, 9.0, -10.0, -10.0, -10.0]);
assert_close_to_vec(&to_vec(policy.reference(loud)), &[7.0, 9.0], 1e-12);
}
#[test]
fn test_max_seen_degrades_to_per_window() {
let policy = RunningMaxClamp::<B>::new();
let window = frames([0.0, -3.0, -1.0, -20.0, 5.0, 4.0, -9.0, 1.0]);
assert_close_to_vec(
&to_vec(policy.reference(window.clone())),
&to_vec(PerWindow.reference(window)),
1e-12,
);
}
#[test]
fn test_reference_does_not_move() {
let mut policy = RunningMaxClamp::<B>::new();
policy.observe(frames([1.0; 8]));
let window = frames([0.0, -3.0, -1.0, -20.0, 5.0, 4.0, -9.0, 1.0]);
let first = to_vec(policy.reference(window.clone()));
let second = to_vec(policy.reference(window));
assert_eq!(first, second);
assert_close_to_vec(&to_vec(policy.seen().unwrap().clone()), &[1.0, 1.0], 1e-12);
}
#[test]
fn test_trait_object() {
let window = frames([0.0, -3.0, -1.0, -20.0, 5.0, 4.0, -9.0, 1.0]);
let mut policies: Vec<Box<dyn StreamClampPolicy<B>>> =
vec![Box::new(PerWindow), Box::new(RunningMaxClamp::new())];
for policy in policies.iter_mut() {
policy.observe(window.clone());
assert_close_to_vec(
&to_vec(policy.reference(window.clone())),
&[0.0, 5.0],
1e-12,
);
assert!(!format!("{policy:?}").is_empty());
let mut copy = policy.clone();
copy.observe(frames([50.0; 8]).clone());
assert_close_to_vec(
&to_vec(policy.reference(window.clone())),
&[0.0, 5.0],
1e-12,
);
assert!(to_vec(copy.reference(window.clone()))[0] >= 0.0);
}
}
}