torsh-nn 0.1.2

Neural network modules for ToRSh with PyTorch-compatible API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Module diagnostics and analysis system
//!
//! This module provides comprehensive diagnostic capabilities for neural network
//! modules including health checking, statistical analysis, and troubleshooting.

// Conditional imports for std/no_std compatibility
#[cfg(feature = "std")]
use std::collections::HashMap;

#[cfg(not(feature = "std"))]
use hashbrown::HashMap;

use crate::ParameterDiagnostics;

/// Module information for debugging and introspection
#[derive(Debug, Clone)]
pub struct ModuleInfo {
    /// Module name (if available)
    pub name: String,
    /// Whether module is in training mode
    pub training: bool,
    /// Total number of parameters
    pub parameter_count: usize,
    /// Number of trainable parameters
    pub trainable_parameter_count: usize,
    /// Memory usage in bytes
    pub memory_usage_bytes: usize,
    /// Whether module has child modules
    pub has_children: bool,
    /// Number of direct child modules
    pub children_count: usize,
}

impl core::fmt::Display for ModuleInfo {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        writeln!(f, "Module: {}", self.name)?;
        writeln!(f, "  Training: {}", self.training)?;
        writeln!(
            f,
            "  Parameters: {} ({} trainable)",
            self.parameter_count, self.trainable_parameter_count
        )?;
        writeln!(
            f,
            "  Memory: {:.2} MB",
            self.memory_usage_bytes as f64 / (1024.0 * 1024.0)
        )?;
        writeln!(
            f,
            "  Children: {} (has_children: {})",
            self.children_count, self.has_children
        )?;
        Ok(())
    }
}

/// Comprehensive module diagnostics
#[derive(Debug, Clone)]
pub struct ModuleDiagnostics {
    /// Basic module information
    pub module_info: ModuleInfo,
    /// Critical issues that need immediate attention
    pub issues: Vec<String>,
    /// Warnings that should be addressed
    pub warnings: Vec<String>,
    /// Parameter-specific diagnostics
    pub parameter_diagnostics: HashMap<String, ParameterDiagnostics>,
}

impl ModuleDiagnostics {
    /// Check if module has any critical issues
    pub fn has_issues(&self) -> bool {
        !self.issues.is_empty()
    }

    /// Check if module has any warnings
    pub fn has_warnings(&self) -> bool {
        !self.warnings.is_empty()
    }

    /// Check if module is healthy (no issues or warnings)
    pub fn is_healthy(&self) -> bool {
        !self.has_issues() && !self.has_warnings()
    }

    /// Get a summary of the health status
    pub fn health_summary(&self) -> String {
        if self.is_healthy() {
            "Healthy".to_string()
        } else {
            format!(
                "{} issues, {} warnings",
                self.issues.len(),
                self.warnings.len()
            )
        }
    }
}

impl core::fmt::Display for ModuleDiagnostics {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        writeln!(f, "Module Diagnostics:")?;
        writeln!(f, "{}", self.module_info)?;

        if !self.issues.is_empty() {
            writeln!(f, "Issues:")?;
            for issue in &self.issues {
                writeln!(f, "  ❌ {}", issue)?;
            }
        }

        if !self.warnings.is_empty() {
            writeln!(f, "Warnings:")?;
            for warning in &self.warnings {
                writeln!(f, "  ⚠️  {}", warning)?;
            }
        }

        if self.is_healthy() {
            writeln!(f, "✅ Module appears healthy")?;
        }

        writeln!(f, "Parameter Health:")?;
        for (name, param_diag) in &self.parameter_diagnostics {
            if param_diag.issues.is_empty() && param_diag.warnings.is_empty() {
                writeln!(f, "  ✅ {}: Healthy", name)?;
            } else {
                writeln!(
                    f,
                    "  ⚠️  {}: {} issues, {} warnings",
                    name,
                    param_diag.issues.len(),
                    param_diag.warnings.len()
                )?;
            }
        }

        Ok(())
    }
}