aprender-core 0.30.0

Next-generation machine learning library in pure Rust
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


impl ConvergenceMetrics {
    /// Create new convergence metrics.
    #[must_use]
    pub fn new() -> Self {
        Self {
            total_iterations: 0,
            successful_fixes: 0,
            failed_fixes: 0,
            iteration_histogram: HashMap::new(),
        }
    }

    /// Record a convergence result.
    pub fn record(&mut self, iterations: usize, success: bool) {
        self.total_iterations += iterations as u64;
        *self.iteration_histogram.entry(iterations).or_insert(0) += 1;

        if success {
            self.successful_fixes += 1;
        } else {
            self.failed_fixes += 1;
        }
    }

    /// Get average iterations to fix.
    #[must_use]
    pub fn average_iterations(&self) -> f64 {
        let total = self.successful_fixes + self.failed_fixes;
        if total == 0 {
            0.0
        } else {
            self.total_iterations as f64 / total as f64
        }
    }

    /// Get convergence success rate.
    #[must_use]
    pub fn success_rate(&self) -> f64 {
        let total = self.successful_fixes + self.failed_fixes;
        if total == 0 {
            0.0
        } else {
            self.successful_fixes as f64 / total as f64
        }
    }

    /// Get total fix attempts.
    #[must_use]
    pub fn total_attempts(&self) -> u64 {
        self.successful_fixes + self.failed_fixes
    }

    /// Get iteration histogram.
    #[must_use]
    pub fn histogram(&self) -> &HashMap<usize, u64> {
        &self.iteration_histogram
    }
}

impl Default for ConvergenceMetrics {
    fn default() -> Self {
        Self::new()
    }
}

/// Summary of all metrics.
#[derive(Debug, Clone)]
pub struct MetricsSummary {
    /// Total fix attempts
    pub total_fix_attempts: u64,
    /// Fix success rate (0.0 to 1.0)
    pub fix_success_rate: f64,
    /// Total compilations
    pub total_compilations: u64,
    /// Average compilation time in milliseconds
    pub avg_compilation_time_ms: f64,
    /// Most common error codes with counts
    pub most_common_errors: Vec<(String, u64)>,
    /// Average iterations to fix
    pub avg_iterations_to_fix: f64,
    /// Convergence rate (0.0 to 1.0)
    pub convergence_rate: f64,
    /// Session duration
    pub session_duration: Duration,
}

impl MetricsSummary {
    /// Format as a human-readable string.
    #[must_use]
    pub fn to_report(&self) -> String {
        let mut report = String::new();
        report.push_str("=== CITL Metrics Summary ===\n\n");

        let _ = writeln!(
            report,
            "Fix Attempts: {} (success rate: {:.1}%)",
            self.total_fix_attempts,
            self.fix_success_rate * 100.0
        );

        let _ = writeln!(
            report,
            "Compilations: {} (avg time: {:.1}ms)",
            self.total_compilations, self.avg_compilation_time_ms
        );

        let _ = writeln!(
            report,
            "Convergence: {:.1}% (avg {:.1} iterations)",
            self.convergence_rate * 100.0,
            self.avg_iterations_to_fix
        );

        if !self.most_common_errors.is_empty() {
            report.push_str("\nMost Common Errors:\n");
            for (code, count) in &self.most_common_errors {
                let _ = writeln!(report, "  {code}: {count}");
            }
        }

        let _ = writeln!(
            report,
            "\nSession Duration: {:.1}s",
            self.session_duration.as_secs_f64()
        );

        report
    }
}