1use crate::backend_authoring::VariableBackend;
2use crate::err::Result;
3use crate::shapes::{DynShape, Shape};
4use crate::tensor::device::Device;
5use crate::tensor::dtype::DType;
6use crate::tensor::transfer::ToDevice;
7use alloc::string::{String, ToString};
8use alloc::vec::Vec;
9
10pub trait ParameterVisitor<B: VariableBackend> {
12 fn visit_param<S, K, Train>(
14 &mut self,
15 path: &crate::nn::StatePath,
16 param: &crate::nn::param::Param<S, B, K, Train>,
17 ) -> Result<()>
18 where
19 S: Shape,
20 K: DType,
21 Train: crate::nn::param::TrainState;
22}
23
24pub trait VisitParameters<B: VariableBackend> {
26 fn flat_width() -> usize
28 where
29 Self: Sized,
30 {
31 1
32 }
33
34 fn visit_parameters<V: ParameterVisitor<B>>(
36 &self,
37 path: &crate::nn::StatePath,
38 visitor: &mut V,
39 ) -> Result<()>;
40
41 fn visit_parameters_flat<V: ParameterVisitor<B>>(
43 &self,
44 parent: &crate::nn::StatePath,
45 base_index: usize,
46 visitor: &mut V,
47 ) -> Result<()>
48 where
49 Self: Sized,
50 {
51 self.visit_parameters(&parent.index(base_index), visitor)
52 }
53}
54
55pub trait TrainMode {
104 #[inline]
110 fn set_training(&mut self, _training: bool) {}
111
112 #[inline]
114 fn train(&mut self) {
115 self.set_training(true);
116 }
117
118 #[inline]
120 fn eval(&mut self) {
121 self.set_training(false);
122 }
123}
124
125pub trait ShapeInfo {
127 fn shape_info(&self) -> Option<String>;
129}
130
131impl<
132 S: Shape + DynShape,
133 B: crate::tensor::backend::VariableBackend,
134 K: DType,
135 Train: crate::nn::param::TrainState,
136> ShapeInfo for crate::nn::param::Param<S, B, K, Train>
137{
138 fn shape_info(&self) -> Option<String> {
139 Some(format!("{:?}", self.shape_dims()))
140 }
141}
142
143impl<S: Shape + DynShape, B: crate::tensor::backend::VariableBackend, K: DType> ShapeInfo
144 for crate::nn::param::Buffer<S, B, K>
145{
146 fn shape_info(&self) -> Option<String> {
147 Some(format!("{:?}", self.shape_dims()))
148 }
149}
150
151impl<T: ShapeInfo> ShapeInfo for Option<T> {
152 fn shape_info(&self) -> Option<String> {
153 self.as_ref().and_then(ShapeInfo::shape_info)
154 }
155}
156
157pub trait Module<Input> {
190 type Output;
192 type Error;
194
195 fn forward(&self, input: Input) -> core::result::Result<Self::Output, Self::Error>;
197}
198
199#[derive(Debug, Clone)]
202pub struct Sequential<L1, L2>(pub L1, pub L2);
203
204impl<I, L1, L2> Module<I> for Sequential<L1, L2>
205where
206 L1: Module<I>,
207 L2: Module<L1::Output, Error = L1::Error>,
208{
209 type Output = L2::Output;
211 type Error = L1::Error;
213
214 #[inline]
215 fn forward(&self, input: I) -> core::result::Result<Self::Output, Self::Error> {
217 let out1 = self.0.forward(input)?;
218 self.1.forward(out1)
219 }
220}
221
222impl<B: crate::tensor::backend::VariableBackend, NewD: Device, L1, L2>
223 crate::tensor::transfer::ToDevice<B, NewD> for Sequential<L1, L2>
224where
225 L1: ToDevice<B, NewD>,
226 L2: ToDevice<B, NewD>,
227{
228 type Output = Sequential<L1::Output, L2::Output>;
230 fn to_device(self, arg: &NewD::Arg) -> Result<Self::Output> {
232 Ok(Sequential(self.0.to_device(arg)?, self.1.to_device(arg)?))
233 }
234}
235
236impl<L1: TrainMode, L2: TrainMode> TrainMode for Sequential<L1, L2> {
242 fn set_training(&mut self, training: bool) {
244 self.0.set_training(training);
245 self.1.set_training(training);
246 }
247}
248
249impl<B, L1, L2> crate::nn::VisitState<B> for Sequential<L1, L2>
250where
251 B: crate::tensor::backend::VariableBackend,
252 L1: crate::nn::VisitState<B>,
253 L2: crate::nn::VisitState<B>,
254{
255 fn flat_width() -> usize {
256 L1::flat_width() + L2::flat_width()
257 }
258
259 fn visit_state<V: crate::nn::StateVisitor<B>>(
260 &self,
261 path: &crate::nn::StatePath,
262 visitor: &mut V,
263 ) -> Result<()> {
264 self.visit_state_flat(path, 0, visitor)
265 }
266
267 fn visit_state_flat<V: crate::nn::StateVisitor<B>>(
268 &self,
269 parent: &crate::nn::StatePath,
270 base_index: usize,
271 visitor: &mut V,
272 ) -> Result<()> {
273 self.0.visit_state_flat(parent, base_index, visitor)?;
274 self.1
275 .visit_state_flat(parent, base_index + L1::flat_width(), visitor)
276 }
277}
278
279impl<B, L1, L2> crate::nn::VisitStateMut<B> for Sequential<L1, L2>
280where
281 B: crate::tensor::backend::VariableBackend,
282 L1: crate::nn::VisitStateMut<B>,
283 L2: crate::nn::VisitStateMut<B>,
284{
285 fn flat_width() -> usize {
286 L1::flat_width() + L2::flat_width()
287 }
288
289 fn visit_state_mut<V: crate::nn::StateMutVisitor<B>>(
290 &mut self,
291 path: &crate::nn::StatePath,
292 visitor: &mut V,
293 ) -> Result<()> {
294 self.visit_state_mut_flat(path, 0, visitor)
295 }
296
297 fn visit_state_mut_flat<V: crate::nn::StateMutVisitor<B>>(
298 &mut self,
299 parent: &crate::nn::StatePath,
300 base_index: usize,
301 visitor: &mut V,
302 ) -> Result<()> {
303 self.0.visit_state_mut_flat(parent, base_index, visitor)?;
304 self.1
305 .visit_state_mut_flat(parent, base_index + L1::flat_width(), visitor)
306 }
307}
308
309impl<B, L1, L2> crate::nn::VisitParameters<B> for Sequential<L1, L2>
310where
311 B: crate::tensor::backend::VariableBackend,
312 L1: crate::nn::VisitParameters<B>,
313 L2: crate::nn::VisitParameters<B>,
314{
315 fn flat_width() -> usize {
316 L1::flat_width() + L2::flat_width()
317 }
318
319 fn visit_parameters<V: crate::nn::ParameterVisitor<B>>(
320 &self,
321 path: &crate::nn::StatePath,
322 visitor: &mut V,
323 ) -> Result<()> {
324 self.visit_parameters_flat(path, 0, visitor)
325 }
326
327 fn visit_parameters_flat<V: crate::nn::ParameterVisitor<B>>(
328 &self,
329 parent: &crate::nn::StatePath,
330 base_index: usize,
331 visitor: &mut V,
332 ) -> Result<()> {
333 self.0.visit_parameters_flat(parent, base_index, visitor)?;
334 self.1
335 .visit_parameters_flat(parent, base_index + L1::flat_width(), visitor)
336 }
337}
338
339impl<T, B: crate::tensor::backend::VariableBackend> crate::nn::VisitStateMut<B>
340 for core::marker::PhantomData<T>
341where
342 T: crate::tensor::dtype::DType,
343{
344 fn visit_state_mut<V: crate::nn::StateMutVisitor<B>>(
345 &mut self,
346 _path: &crate::nn::StatePath,
347 _visitor: &mut V,
348 ) -> Result<()> {
349 Ok(())
350 }
351}
352
353impl<L, B> crate::nn::VisitState<B> for Option<L>
354where
355 L: crate::nn::VisitState<B>,
356 B: crate::tensor::backend::VariableBackend,
357{
358 fn visit_state<V: crate::nn::StateVisitor<B>>(
359 &self,
360 path: &crate::nn::StatePath,
361 visitor: &mut V,
362 ) -> Result<()> {
363 if let Some(value) = self {
364 value.visit_state(path, visitor)?;
365 }
366 Ok(())
367 }
368}
369
370impl<L, B> crate::nn::VisitStateMut<B> for Option<L>
371where
372 L: crate::nn::VisitStateMut<B>,
373 B: crate::tensor::backend::VariableBackend,
374{
375 fn visit_state_mut<V: crate::nn::StateMutVisitor<B>>(
376 &mut self,
377 path: &crate::nn::StatePath,
378 visitor: &mut V,
379 ) -> Result<()> {
380 if let Some(value) = self {
381 value.visit_state_mut(path, visitor)?;
382 }
383 Ok(())
384 }
385}
386
387impl<L, B> crate::nn::VisitParameters<B> for Option<L>
388where
389 L: crate::nn::VisitParameters<B>,
390 B: crate::tensor::backend::VariableBackend,
391{
392 fn visit_parameters<V: crate::nn::ParameterVisitor<B>>(
393 &self,
394 path: &crate::nn::StatePath,
395 visitor: &mut V,
396 ) -> Result<()> {
397 if let Some(value) = self {
398 value.visit_parameters(path, visitor)?;
399 }
400 Ok(())
401 }
402}
403
404#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
406pub struct LayerNode {
407 pub name: String,
409 pub type_name: String,
411 pub shape_info: String,
413 pub children: Vec<LayerNode>,
415}
416
417pub trait NamedLayers {
419 fn layer_structure(&self, prefix: &str) -> Vec<LayerNode>;
421
422 fn summary(&self) -> String {
424 format_layer_summary(&self.layer_structure(""))
425 }
426
427 fn summary_with_stats(&self, batch: u64) -> String
433 where
434 Self: crate::nn::stats::ComputeStats,
435 {
436 format_layer_summary_with_stats(&self.layer_structure(""), self.stats(batch))
437 }
438}
439
440pub fn format_layer_summary(nodes: &[LayerNode]) -> String {
442 let mut out = String::new();
443 out.push_str(
444 "================================================================================\n",
445 );
446 out.push_str(&format!(
447 "{:<32} {:<28} {:<16}\n",
448 "Layer (Name: Type)", "Shape / Spec", "Details"
449 ));
450 out.push_str(
451 "================================================================================\n",
452 );
453
454 fn print_node(node: &LayerNode, indent: usize, out: &mut String) {
455 let indent_str = " ".repeat(indent);
456 let clean_type = clean_type_name(&node.type_name);
457 let name_type = if node.name.is_empty() {
458 format!("{}{}", indent_str, clean_type)
459 } else {
460 format!("{}{}: {}", indent_str, node.name, clean_type)
461 };
462 let shape = if node.shape_info.is_empty() {
463 "-"
464 } else {
465 &node.shape_info
466 };
467 out.push_str(&format!("{:<32} {:<28} {:<16}\n", name_type, shape, "-"));
468 for child in &node.children {
469 print_node(child, indent + 1, out);
470 }
471 }
472
473 for node in nodes {
474 print_node(node, 0, &mut out);
475 }
476 out.push_str(
477 "================================================================================\n",
478 );
479 out
480}
481
482pub fn format_layer_summary_with_stats(
492 nodes: &[LayerNode],
493 stats: crate::nn::stats::ModelStats,
494) -> String {
495 let mut out = format_layer_summary(nodes);
496 out.push_str(&format!(
497 "Total params: {} MACs: {} FLOPs: {}\n",
498 stats.params, stats.macs, stats.flops
499 ));
500 out.push_str(
501 "================================================================================\n",
502 );
503 out
504}
505
506pub fn clean_type_name(raw: &str) -> String {
508 let without_generics = match raw.find('<') {
509 Some(idx) => &raw[..idx],
510 None => raw,
511 };
512 let name = match without_generics.rfind("::") {
513 Some(idx) => &without_generics[idx + 2..],
514 None => without_generics,
515 };
516 name.trim().to_string()
517}
518
519pub fn update_node_name_prefix(node: &mut LayerNode, new_name: &str) {
521 let old_name = node.name.clone();
522 node.name = new_name.to_string();
523 for child in &mut node.children {
524 let child_suffix = if old_name.is_empty() {
525 &child.name
526 } else if child.name.starts_with(&old_name) {
527 let prefix_len = old_name.len();
528 if child.name.len() > prefix_len && child.name.as_bytes()[prefix_len] == b'.' {
529 &child.name[prefix_len + 1..]
530 } else {
531 &child.name[prefix_len..]
532 }
533 } else {
534 &child.name
535 };
536 let new_child_name = if new_name.is_empty() {
537 child_suffix.to_string()
538 } else {
539 format!("{}.{}", new_name, child_suffix)
540 };
541 update_node_name_prefix(child, &new_child_name);
542 }
543}
544
545pub fn assign_sequential_names(nodes: &mut [LayerNode], prefix: &str) {
547 let mut type_counts = alloc::collections::BTreeMap::new();
548 for (i, node) in nodes.iter_mut().enumerate() {
549 let clean_type = clean_type_name(&node.type_name);
550 let count = type_counts.entry(clean_type.clone()).or_insert(0);
551 *count += 1;
552
553 let seq_name = if !clean_type.is_empty() && clean_type != "LayerNode" {
554 format!("{}{}", clean_type, count)
555 } else {
556 format!("{}", i)
557 };
558
559 let new_name = if prefix.is_empty() {
560 seq_name
561 } else {
562 format!("{}.{}", prefix, seq_name)
563 };
564
565 update_node_name_prefix(node, &new_name);
566 }
567}
568
569impl<L1: NamedLayers, L2: NamedLayers> NamedLayers for Sequential<L1, L2> {
570 fn layer_structure(&self, prefix: &str) -> Vec<LayerNode> {
572 let mut nodes = Vec::new();
573 nodes.extend(self.0.layer_structure(""));
574 nodes.extend(self.1.layer_structure(""));
575
576 assign_sequential_names(&mut nodes, prefix);
577 nodes
578 }
579}
580
581impl<T: NamedLayers> NamedLayers for Option<T> {
582 fn layer_structure(&self, prefix: &str) -> Vec<LayerNode> {
584 if let Some(layer) = self {
585 layer.layer_structure(prefix)
586 } else {
587 Vec::new()
588 }
589 }
590}
591
592impl<T: TrainMode> TrainMode for Option<T> {
593 fn set_training(&mut self, training: bool) {
594 if let Some(value) = self {
595 value.set_training(training);
596 }
597 }
598}
599
600impl<
601 S: Shape + DynShape,
602 B: crate::tensor::backend::VariableBackend,
603 K: DType,
604 Train: crate::nn::param::TrainState,
605> NamedLayers for crate::nn::param::Param<S, B, K, Train>
606{
607 fn layer_structure(&self, _prefix: &str) -> Vec<LayerNode> {
608 Vec::new()
609 }
610}
611
612impl<S: Shape + DynShape, B: crate::tensor::backend::VariableBackend, K: DType> NamedLayers
613 for crate::nn::param::Buffer<S, B, K>
614{
615 fn layer_structure(&self, _prefix: &str) -> Vec<LayerNode> {
616 Vec::new()
617 }
618}
619
620impl<
621 S: Shape + DynShape,
622 B: crate::tensor::backend::VariableBackend,
623 K: DType,
624 Train: crate::nn::param::TrainState,
625> TrainMode for crate::nn::param::Param<S, B, K, Train>
626{
627}
628
629impl<S: Shape + DynShape, B: crate::tensor::backend::VariableBackend, K: DType> TrainMode
630 for crate::nn::param::Buffer<S, B, K>
631{
632}
633
634#[macro_export]
642macro_rules! seq {
643 ($l1:expr) => {
644 $l1
645 };
646 ($l1:expr, $($tail:expr),+ $(,)?) => {
647 $crate::nn::Sequential($l1, $crate::seq!($($tail),+))
648 };
649}
650
651#[macro_export]
685macro_rules! SeqTy {
686 ($l1:ty) => {
687 $l1
688 };
689 ($l1:ty, $($tail:ty),+ $(,)?) => {
690 $crate::nn::Sequential<$l1, $crate::SeqTy!($($tail),+)>
691 };
692}
693
694#[macro_export]
695#[doc(hidden)]
696macro_rules! seq_ty {
697 ($($tokens:tt)*) => {
698 $crate::SeqTy!($($tokens)*)
699 };
700}
701
702#[macro_export]
703#[doc(hidden)]
704macro_rules! seq_type {
705 ($($tokens:tt)*) => {
706 $crate::SeqTy!($($tokens)*)
707 };
708}