minet_ai 0.1.4

MiNET AI (Miniaturized Neural Evolutionary Topology) is a minimalistic Rust library that evolves small neural networks via genetic algorithm. With a focus on producing compact, adaptive networks that evolve to solve any problem they are given.
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

use crate::minet;

impl minet {
    pub fn display(
        &self,
    ) {
        println!("===== GENOME =====");
        let inputs = self.input as usize;
        let outputs = self.output as usize;
        let length = self.genes.len();
        let hidden_space = length - outputs;
        let synapses_count = self.synapse_count();
        for (i, gene) in self.genes.iter().enumerate() {
            let mut neuron_type: &str = "";
            if i < inputs { 
                neuron_type = "Input";
            }
            if i >= inputs && i < hidden_space {
                neuron_type = "Hidden";
            } 
            if i >= hidden_space {
                neuron_type = "Output";
            }
            println!(
                "{} | {} :: Bias: {}, Synapses: {:.2?}",
                i , neuron_type, gene.0, gene.1
            );

        }
        println!("Synapses: {}", synapses_count);
        println!("Fitness: {}", self.fitness);
    }
    
    pub fn to_dot(&self) -> String {
        let mut dot = String::new();
        dot.push_str("digraph Minet {\n");
        dot.push_str("    // Use left-to-right orientation\n");
        dot.push_str("    rankdir=LR;\n");
        dot.push_str("    graph [layout=dot, fontname=\"Helvetica\", fontsize=12];\n");
        dot.push_str("    node [fontname=\"Helvetica\", fontsize=10];\n");
        dot.push_str("    edge [fontname=\"Helvetica\", fontsize=10];\n\n");
    
        let input_start = 0;
        let input_end = self.input;
        let hidden_start = self.input;
        let hidden_end = self.input + self.hidden;
        let output_start = hidden_end;
        let output_end = hidden_end + self.output;
    
        // Input Layer
        dot.push_str("    subgraph cluster_inputs {\n");
        dot.push_str("        style=filled;\n");
        dot.push_str("        color=\"#cceeff\";\n");
        dot.push_str("        penwidth=1.5;\n");
        dot.push_str("        label=\"Input Layer\";\n");
        dot.push_str("        labelloc=\"top\";\n");
        dot.push_str("        labeljust=\"center\";\n");
        dot.push_str("        rank=same;\n");
        for i in input_start..input_end {
            let bias = self.genes[i].0;
            dot.push_str(&format!(
                "        neuron_{} [shape=box, style=filled, fillcolor=white, penwidth=1.5, label=\"In:{}\\nBias={:.2}\"];\n",
                i, i, bias
            ));
        }
        dot.push_str("    }\n\n");
    
        // Hidden Layer
        dot.push_str("    subgraph cluster_hidden {\n");
        dot.push_str("        style=filled;\n");
        dot.push_str("        color=\"#e6e6e6\";\n");
        dot.push_str("        penwidth=1.5;\n");
        dot.push_str("        label=\"Hidden Layer\";\n");
        dot.push_str("        labelloc=\"top\";\n");
        dot.push_str("        labeljust=\"center\";\n");
        for i in hidden_start..hidden_end {
            let bias = self.genes[i].0;
            dot.push_str(&format!(
                "        neuron_{} [shape=ellipse, style=filled, fillcolor=white, penwidth=1.5, label=\"H:{}\\nBias={:.2}\"];\n",
                i, i, bias
            ));
        }
        dot.push_str("    }\n\n");
    
        // Output Layer
        dot.push_str("    subgraph cluster_outputs {\n");
        dot.push_str("        style=filled;\n");
        dot.push_str("        color=\"#ccffcc\";\n");
        dot.push_str("        penwidth=1.5;\n");
        dot.push_str("        label=\"Output Layer\";\n");
        dot.push_str("        labelloc=\"top\";\n");
        dot.push_str("        labeljust=\"center\";\n");
        dot.push_str("        rank=same;\n");
        for i in output_start..output_end {
            let bias = self.genes[i].0;
            dot.push_str(&format!(
                "        neuron_{} [shape=doublecircle, style=filled, fillcolor=white, penwidth=1.5, label=\"Out:{}\\nBias={:.2}\"];\n",
                i, i, bias
            ));
        }
        dot.push_str("    }\n\n");
    
        // Edges
        dot.push_str("    // Edges\n");
        dot.push_str("    edge [color=\"#555555\", penwidth=1.2];\n");
        for (src, (_, synapses)) in self.genes.iter().enumerate() {
            for &(tgt, weight) in synapses {
                dot.push_str(&format!(
                    "    neuron_{} -> neuron_{} [label=\"{:.2}\", fontcolor=\"#333333\"];\n",
                    src, tgt, weight
                ));
            }
        }
    
        dot.push_str("}\n");
        dot
    }
    
    pub fn dot_to_file(
        &self, 
        filename: &str
    ) -> std::io::Result<()> {
        let dot_representation = self.to_dot();
        std::fs::write(filename, dot_representation)
    }
    
    pub fn display_genome(
        &self,
    ) {
        let encoded = self.encode();
        let piece_length = encoded.len() / self.hidden;
        let mut pieces = Vec::new();
        for i in 0..self.hidden {
            let start = i * piece_length;
            let end = start + piece_length;
            pieces.push(&encoded[start..end]);
        }
        for i in 0..pieces.len() {
            println!("{}",pieces[i]);
        }
    }

}