rfann 0.1.0

A pure Rust implementation of the Fast Artificial Neural Network (FANN) library
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! DOT format export for network visualization

use crate::io::error::IoResult;
use std::io::Write;

// Import the mock types for now
use crate::mock_types::MockNetwork;

/// DOT format exporter for network visualization
pub struct DotExporter {
    /// Show weights on edges
    pub show_weights: bool,
    /// Show neuron indices
    pub show_indices: bool,
    /// Graph layout direction
    pub layout_direction: LayoutDirection,
}

/// Graph layout direction
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LayoutDirection {
    /// Left to right (default for neural networks)
    LeftToRight,
    /// Top to bottom
    TopToBottom,
    /// Right to left
    RightToLeft,
    /// Bottom to top
    BottomToTop,
}

impl DotExporter {
    /// Create a new DOT exporter with default settings
    pub fn new() -> Self {
        Self {
            show_weights: false,
            show_indices: true,
            layout_direction: LayoutDirection::LeftToRight,
        }
    }

    /// Create a new DOT exporter with custom settings
    pub fn with_options(
        show_weights: bool,
        show_indices: bool,
        layout_direction: LayoutDirection,
    ) -> Self {
        Self {
            show_weights,
            show_indices,
            layout_direction,
        }
    }

    /// Export a neural network to DOT format
    pub fn export_network<W: Write>(&self, network: &MockNetwork, writer: &mut W) -> IoResult<()> {
        writeln!(writer, "digraph NeuralNetwork {{")?;

        // Set graph attributes
        let rankdir = match self.layout_direction {
            LayoutDirection::LeftToRight => "LR",
            LayoutDirection::TopToBottom => "TB",
            LayoutDirection::RightToLeft => "RL",
            LayoutDirection::BottomToTop => "BT",
        };
        writeln!(writer, "  rankdir={rankdir};")?;
        writeln!(writer, "  node [shape=circle];",)?;
        writeln!(writer, "  edge [dir=forward];",)?;
        writeln!(writer)?;

        // Create nodes for each layer
        let mut node_id = 0;
        let mut layer_nodes = Vec::new();

        for (layer_idx, &layer_size) in network.layer_sizes.iter().enumerate() {
            writeln!(writer, "  // Layer {layer_idx}")?;
            writeln!(writer, "  {{")?;
            writeln!(writer, "    rank=same;")?;

            let mut current_layer_nodes = Vec::new();

            for neuron_idx in 0..layer_size {
                let label = if self.show_indices {
                    format!("L{layer_idx}N{neuron_idx}")
                } else {
                    match layer_idx {
                        0 => format!("I{neuron_idx}"),
                        idx if idx == network.layer_sizes.len() - 1 => format!("O{neuron_idx}"),
                        _ => format!("H{neuron_idx}"),
                    }
                };

                writeln!(writer, "    n{node_id} [label=\"{label}\"];")?;
                current_layer_nodes.push(node_id);
                node_id += 1;
            }

            writeln!(writer, "  }}")?;
            writeln!(writer)?;

            layer_nodes.push(current_layer_nodes);
        }

        // Create edges between layers
        for layer_idx in 0..layer_nodes.len() - 1 {
            let current_layer = &layer_nodes[layer_idx];
            let next_layer = &layer_nodes[layer_idx + 1];

            writeln!(
                writer,
                "  // Connections from layer {} to layer {}",
                layer_idx,
                layer_idx + 1
            )?;

            for &from_node in current_layer {
                for &to_node in next_layer {
                    if self.show_weights && !network.weights.is_empty() {
                        // For demonstration, use a simple weight assignment
                        // In a real implementation, this would use actual network topology
                        let weight_idx = (from_node + to_node) % network.weights.len();
                        let weight = network.weights[weight_idx];

                        let color = if weight > 0.0 { "blue" } else { "red" };
                        let width = (weight.abs() * 5.0).clamp(0.5, 5.0);

                        writeln!(
                            writer,
                            "  n{from_node} -> n{to_node} [label=\"{weight:.3}\", color={color}, penwidth={width:.1}];"
                        )?;
                    } else {
                        writeln!(writer, "  n{from_node} -> n{to_node};")?;
                    }
                }
            }
            writeln!(writer)?;
        }

        // Add network information as a comment
        writeln!(writer, "  // Network Information")?;
        writeln!(writer, "  // Layers: {}", network.num_layers)?;
        writeln!(writer, "  // Learning Rate: {:.6}", network.learning_rate)?;
        writeln!(
            writer,
            "  // Connection Rate: {:.6}",
            network.connection_rate
        )?;

        writeln!(writer, "}}")?;

        Ok(())
    }
}

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