1use crate::module::{Module, ModuleError};
2use coeus_autograd::Var;
3use coeus_core::{Float, MoiraiBackend, Scalar};
4use std::marker::PhantomData;
5
6#[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 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#[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 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#[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 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#[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 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#[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 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}