use crate::module::{Module, ModuleError};
use coeus_autograd::Var;
use coeus_core::{Float, MoiraiBackend, Scalar};
use std::marker::PhantomData;
#[derive(Clone, Default)]
pub struct GlobalAvgPool1d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
PhantomData<(T, B)>,
);
impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
GlobalAvgPool1d<T, B>
{
pub const fn new() -> Self {
Self(PhantomData)
}
}
impl<
T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
B: coeus_ops::BackendOps<T> + Default,
> Module<T, B> for GlobalAvgPool1d<T, B>
{
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
let actual = input.tensor.ndim();
if actual != 3 {
return Err(ModuleError::InvalidRank {
module: "GlobalAvgPool1d",
expected: "3",
actual,
});
}
if input.tensor.shape()[2] == 0 {
return Err(ModuleError::ShapeMismatch {
module: "GlobalAvgPool1d",
parameter: "spatial dimensions",
expected: vec![1],
actual: vec![0],
});
}
Ok(coeus_autograd::mean_axis(input, 2)?)
}
}
#[derive(Clone, Default)]
pub struct GlobalAvgPool2d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
PhantomData<(T, B)>,
);
impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
GlobalAvgPool2d<T, B>
{
pub const fn new() -> Self {
Self(PhantomData)
}
}
impl<
T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
B: coeus_ops::BackendOps<T> + Default,
> Module<T, B> for GlobalAvgPool2d<T, B>
{
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
let actual = input.tensor.ndim();
if actual != 4 {
return Err(ModuleError::InvalidRank {
module: "GlobalAvgPool2d",
expected: "4",
actual,
});
}
let spatial = &input.tensor.shape()[2..];
if spatial.contains(&0) {
return Err(ModuleError::ShapeMismatch {
module: "GlobalAvgPool2d",
parameter: "spatial dimensions",
expected: vec![1; 2],
actual: spatial.to_vec(),
});
}
let after_h = coeus_autograd::mean_axis(input, 2)?;
Ok(coeus_autograd::mean_axis(&after_h, 3)?)
}
}
#[derive(Clone, Default)]
pub struct GlobalAvgPool3d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
PhantomData<(T, B)>,
);
impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
GlobalAvgPool3d<T, B>
{
pub const fn new() -> Self {
Self(PhantomData)
}
}
impl<
T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
B: coeus_ops::BackendOps<T> + Default,
> Module<T, B> for GlobalAvgPool3d<T, B>
{
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
let actual = input.tensor.ndim();
if actual != 5 {
return Err(ModuleError::InvalidRank {
module: "GlobalAvgPool3d",
expected: "5",
actual,
});
}
let spatial = &input.tensor.shape()[2..];
if spatial.contains(&0) {
return Err(ModuleError::ShapeMismatch {
module: "GlobalAvgPool3d",
parameter: "spatial dimensions",
expected: vec![1; 3],
actual: spatial.to_vec(),
});
}
let after_d = coeus_autograd::mean_axis(input, 2)?;
let after_h = coeus_autograd::mean_axis(&after_d, 3)?;
Ok(coeus_autograd::mean_axis(&after_h, 4)?)
}
}
#[derive(Clone, Default)]
pub struct GlobalMaxPool2d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
PhantomData<(T, B)>,
);
impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
GlobalMaxPool2d<T, B>
{
pub const fn new() -> Self {
Self(PhantomData)
}
}
impl<
T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
B: coeus_ops::BackendOps<T> + Default,
> Module<T, B> for GlobalMaxPool2d<T, B>
{
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
let actual = input.tensor.ndim();
if actual != 4 {
return Err(ModuleError::InvalidRank {
module: "GlobalMaxPool2d",
expected: "4",
actual,
});
}
let spatial = &input.tensor.shape()[2..];
if spatial.contains(&0) {
return Err(ModuleError::ShapeMismatch {
module: "GlobalMaxPool2d",
parameter: "spatial dimensions",
expected: vec![1; 2],
actual: spatial.to_vec(),
});
}
let after_h = coeus_autograd::max_axis(input, 2)?;
Ok(coeus_autograd::max_axis(&after_h, 3)?)
}
}
#[derive(Clone, Default)]
pub struct GlobalMaxPool3d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
PhantomData<(T, B)>,
);
impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
GlobalMaxPool3d<T, B>
{
pub const fn new() -> Self {
Self(PhantomData)
}
}
impl<
T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
B: coeus_ops::BackendOps<T> + Default,
> Module<T, B> for GlobalMaxPool3d<T, B>
{
fn parameters(&self) -> Vec<Var<T, B>> {
vec![]
}
fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
let actual = input.tensor.ndim();
if actual != 5 {
return Err(ModuleError::InvalidRank {
module: "GlobalMaxPool3d",
expected: "5",
actual,
});
}
let spatial = &input.tensor.shape()[2..];
if spatial.contains(&0) {
return Err(ModuleError::ShapeMismatch {
module: "GlobalMaxPool3d",
parameter: "spatial dimensions",
expected: vec![1; 3],
actual: spatial.to_vec(),
});
}
let after_d = coeus_autograd::max_axis(input, 2)?;
let after_h = coeus_autograd::max_axis(&after_d, 3)?;
Ok(coeus_autograd::max_axis(&after_h, 4)?)
}
}