Skip to main content

coeus_nn/pool/
global.rs

1use crate::module::{Module, ModuleError};
2use coeus_autograd::Var;
3use coeus_core::{Float, MoiraiBackend, Scalar};
4use std::marker::PhantomData;
5
6// ── Global average pooling ─────────────────────────────────────────────────
7//
8// GlobalAvgPool{1,2,3}d reduces all spatial dimensions to 1, equivalent to
9// `AvgPool{N}d(kernel_size=spatial_size, stride=1)`.  They are zero-parameter
10// ZST modules (PhantomData only) so there is no allocation overhead.
11
12/// Global average pooling for 3-D inputs `[N, C, L]` → `[N, C, 1]`.
13///
14/// Equivalent to `torch.nn.AdaptiveAvgPool1d(1)`.
15#[derive(Clone, Default)]
16pub struct GlobalAvgPool1d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
17    PhantomData<(T, B)>,
18);
19
20impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
21    GlobalAvgPool1d<T, B>
22{
23    /// Create a new `GlobalAvgPool1d` (zero-sized, no parameters).
24    pub const fn new() -> Self {
25        Self(PhantomData)
26    }
27}
28
29impl<
30        T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
31        B: coeus_ops::BackendOps<T> + Default,
32    > Module<T, B> for GlobalAvgPool1d<T, B>
33{
34    fn parameters(&self) -> Vec<Var<T, B>> {
35        vec![]
36    }
37
38    fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
39        let actual = input.tensor.ndim();
40        if actual != 3 {
41            return Err(ModuleError::InvalidRank {
42                module: "GlobalAvgPool1d",
43                expected: "3",
44                actual,
45            });
46        }
47        if input.tensor.shape()[2] == 0 {
48            return Err(ModuleError::ShapeMismatch {
49                module: "GlobalAvgPool1d",
50                parameter: "spatial dimensions",
51                expected: vec![1],
52                actual: vec![0],
53            });
54        }
55        Ok(coeus_autograd::mean_axis(input, 2)?)
56    }
57}
58
59/// Global average pooling for 4-D inputs `[N, C, H, W]` → `[N, C, 1, 1]`.
60///
61/// Equivalent to `torch.nn.AdaptiveAvgPool2d(1)`.
62#[derive(Clone, Default)]
63pub struct GlobalAvgPool2d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
64    PhantomData<(T, B)>,
65);
66
67impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
68    GlobalAvgPool2d<T, B>
69{
70    /// Create a new `GlobalAvgPool2d` (zero-sized, no parameters).
71    pub const fn new() -> Self {
72        Self(PhantomData)
73    }
74}
75
76impl<
77        T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
78        B: coeus_ops::BackendOps<T> + Default,
79    > Module<T, B> for GlobalAvgPool2d<T, B>
80{
81    fn parameters(&self) -> Vec<Var<T, B>> {
82        vec![]
83    }
84
85    fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
86        let actual = input.tensor.ndim();
87        if actual != 4 {
88            return Err(ModuleError::InvalidRank {
89                module: "GlobalAvgPool2d",
90                expected: "4",
91                actual,
92            });
93        }
94        let spatial = &input.tensor.shape()[2..];
95        if spatial.contains(&0) {
96            return Err(ModuleError::ShapeMismatch {
97                module: "GlobalAvgPool2d",
98                parameter: "spatial dimensions",
99                expected: vec![1; 2],
100                actual: spatial.to_vec(),
101            });
102        }
103        let after_h = coeus_autograd::mean_axis(input, 2)?;
104        Ok(coeus_autograd::mean_axis(&after_h, 3)?)
105    }
106}
107
108/// Global average pooling for 5-D inputs `[N, C, D, H, W]` → `[N, C, 1, 1, 1]`.
109///
110/// Equivalent to `torch.nn.AdaptiveAvgPool3d(1)`.
111#[derive(Clone, Default)]
112pub struct GlobalAvgPool3d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
113    PhantomData<(T, B)>,
114);
115
116impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
117    GlobalAvgPool3d<T, B>
118{
119    /// Create a new `GlobalAvgPool3d` (zero-sized, no parameters).
120    pub const fn new() -> Self {
121        Self(PhantomData)
122    }
123}
124
125impl<
126        T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
127        B: coeus_ops::BackendOps<T> + Default,
128    > Module<T, B> for GlobalAvgPool3d<T, B>
129{
130    fn parameters(&self) -> Vec<Var<T, B>> {
131        vec![]
132    }
133
134    fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
135        let actual = input.tensor.ndim();
136        if actual != 5 {
137            return Err(ModuleError::InvalidRank {
138                module: "GlobalAvgPool3d",
139                expected: "5",
140                actual,
141            });
142        }
143        let spatial = &input.tensor.shape()[2..];
144        if spatial.contains(&0) {
145            return Err(ModuleError::ShapeMismatch {
146                module: "GlobalAvgPool3d",
147                parameter: "spatial dimensions",
148                expected: vec![1; 3],
149                actual: spatial.to_vec(),
150            });
151        }
152        let after_d = coeus_autograd::mean_axis(input, 2)?;
153        let after_h = coeus_autograd::mean_axis(&after_d, 3)?;
154        Ok(coeus_autograd::mean_axis(&after_h, 4)?)
155    }
156}
157
158/// Global max pooling for 4-D inputs `[N, C, H, W]` → `[N, C, 1, 1]`.
159///
160/// Equivalent to `torch.nn.AdaptiveMaxPool2d(1)`.
161#[derive(Clone, Default)]
162pub struct GlobalMaxPool2d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
163    PhantomData<(T, B)>,
164);
165
166impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
167    GlobalMaxPool2d<T, B>
168{
169    /// Create a new `GlobalMaxPool2d` (zero-sized, no parameters).
170    pub const fn new() -> Self {
171        Self(PhantomData)
172    }
173}
174
175impl<
176        T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
177        B: coeus_ops::BackendOps<T> + Default,
178    > Module<T, B> for GlobalMaxPool2d<T, B>
179{
180    fn parameters(&self) -> Vec<Var<T, B>> {
181        vec![]
182    }
183
184    fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
185        let actual = input.tensor.ndim();
186        if actual != 4 {
187            return Err(ModuleError::InvalidRank {
188                module: "GlobalMaxPool2d",
189                expected: "4",
190                actual,
191            });
192        }
193        let spatial = &input.tensor.shape()[2..];
194        if spatial.contains(&0) {
195            return Err(ModuleError::ShapeMismatch {
196                module: "GlobalMaxPool2d",
197                parameter: "spatial dimensions",
198                expected: vec![1; 2],
199                actual: spatial.to_vec(),
200            });
201        }
202        let after_h = coeus_autograd::max_axis(input, 2)?;
203        Ok(coeus_autograd::max_axis(&after_h, 3)?)
204    }
205}
206
207/// Global max pooling for 5-D inputs `[N, C, D, H, W]` → `[N, C, 1, 1, 1]`.
208#[derive(Clone, Default)]
209pub struct GlobalMaxPool3d<T: Scalar, B: coeus_ops::BackendOps<T> + Default = MoiraiBackend>(
210    PhantomData<(T, B)>,
211);
212
213impl<T: coeus_core::FloatElement + Scalar, B: coeus_ops::BackendOps<T> + Default>
214    GlobalMaxPool3d<T, B>
215{
216    /// Create a new `GlobalMaxPool3d` (zero-sized, no parameters).
217    pub const fn new() -> Self {
218        Self(PhantomData)
219    }
220}
221
222impl<
223        T: coeus_core::FloatElement + Float + coeus_cpu::RealScalar,
224        B: coeus_ops::BackendOps<T> + Default,
225    > Module<T, B> for GlobalMaxPool3d<T, B>
226{
227    fn parameters(&self) -> Vec<Var<T, B>> {
228        vec![]
229    }
230
231    fn forward(&self, input: &Var<T, B>) -> Result<Var<T, B>, ModuleError<B::Error>> {
232        let actual = input.tensor.ndim();
233        if actual != 5 {
234            return Err(ModuleError::InvalidRank {
235                module: "GlobalMaxPool3d",
236                expected: "5",
237                actual,
238            });
239        }
240        let spatial = &input.tensor.shape()[2..];
241        if spatial.contains(&0) {
242            return Err(ModuleError::ShapeMismatch {
243                module: "GlobalMaxPool3d",
244                parameter: "spatial dimensions",
245                expected: vec![1; 3],
246                actual: spatial.to_vec(),
247            });
248        }
249        let after_d = coeus_autograd::max_axis(input, 2)?;
250        let after_h = coeus_autograd::max_axis(&after_d, 3)?;
251        Ok(coeus_autograd::max_axis(&after_h, 4)?)
252    }
253}