Struct set_genome::Genome

pub struct Genome {
    pub inputs: Genes<Node>,
    pub hidden: Genes<Node>,
    pub outputs: Genes<Node>,
    pub feed_forward: Genes<Connection>,
    pub recurrent: Genes<Connection>,
}

This is the core data structure this crate revoles around.

A genome can be changed by mutation (a random alteration of its structure) or by crossing in another genome (recombining their matching parts). A lot of additional information explaining details of the structure can be found in the thesis that developed this idea. More and more knowledge from there will find its way into this documentaion over time.

Fields

inputs: Genes<Node>

hidden: Genes<Node>

outputs: Genes<Node>

feed_forward: Genes<Connection>

recurrent: Genes<Connection>

Implementations

impl Genome

pub fn new(structure: &Structure) -> Self

Creates a new genome according to the Structure it is given. It generates all necessary identities based on an RNG seeded from a hash of the I/O configuration of the structure. This allows genomes of identical I/O configuration to be crossed over in a meaningful way.

pub fn nodes(&self) -> impl Iterator<Item = &Node>

Returns an iterator over references to all node genes (input + hidden + output) in the genome.

pub fn contains(&self, id: Id) -> bool

pub fn connections(&self) -> impl Iterator<Item = &Connection>

Returns an iterator over references to all connection genes (feed-forward + recurrent) in the genome.

pub fn init(&mut self, structure: &Structure)

Initializes a genome, i.e. connects the in the Structure configured percent of inputs to all outputs by creating connection genes with random weights.

pub fn len(&self) -> usize

Returns the sum of connection genes inside the genome (feed-forward + recurrent).

pub fn is_empty(&self) -> bool

Is true when no connection genes are present in the genome.

pub fn cross_in(&self, other: &Self) -> Self

Cross-in another genome. For connection genes present in both genomes flip a coin to determine the weight inside the new genome. For node genes present in both genomes flip a coin to determine the activation function inside the new genome. Any structure not present in other is taken over unchanged from self.

pub fn would_form_cycle(&self, start_node: &Node, end_node: &Node) -> bool

Check if connecting start_node and end_node would introduce a circle into the ANN structure. Think about the ANN as a graph for this, if you follow the connection arrows, can you reach start_node from end_node?

pub fn has_alternative_input(&self, node: Id, exclude: Id) -> bool

Check if a node gene has more than one connection gene pointing to it.

pub fn has_alternative_output(&self, node: Id, exclude: Id) -> bool

Check if a node gene has more than one connection gene leaving it.

pub fn dot(genome: &Self) -> String

Get the encoded neural network as a string in DOT format.

The output can be visualized here for example.

impl Genome

pub fn uninitialized(parameters: &Parameters) -> Self

Initialization connects the configured percent of inputs nodes to output nodes, i.e. it creates connection genes with random weights.

pub fn initialized(parameters: &Parameters) -> Self

pub fn mutate(&mut self, parameters: &Parameters) -> MutationResult

Apply all mutations listed in the Parameters with respect to their chance of happening. If a mutation is listed multiple times it is applied multiple times.

This will probably be the most common way to apply mutations to a genome.

Examples

use set_genome::{Genome, Parameters};

// Create parameters, usually read from a configuration file.
let parameters = Parameters::default();

// Create an initialized `Genome`.
let mut genome = Genome::initialized(&parameters);

// Randomly mutate the genome according to the available mutations listed in the parameters of the context and their corresponding chances .
genome.mutate(&parameters);

Trait Implementations

impl Clone for Genome

fn clone(&self) -> Genome

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Genome

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Genome

fn default() -> Genome

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Genome

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Genome

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl NetworkLike<Node, Connection> for Genome

fn nodes(&self) -> Vec<&Node>

fn edges(&self) -> Vec<&Connection>

fn inputs(&self) -> Vec<&Node>

fn outputs(&self) -> Vec<&Node>

fn hidden(&self) -> Vec<&Node>

impl PartialEq<Genome> for Genome

fn eq(&self, other: &Genome) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Recurrent<Node, Connection> for Genome

fn recurrent_edges(&self) -> Vec<&Connection>

impl Serialize for Genome

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Genome

impl StructuralEq for Genome

impl StructuralPartialEq for Genome