Struct Mutation 

pub struct Mutation { /* private fields */ }

Genetic Program mutation. Configures crossover (mating) on GP individuals.

Implementations

impl Mutation

pub fn uniform() -> Mutation

Perform mutation by randomly replacing a node with a new subtree.

Examples found in repository

examples/snake.rs (line 272)

fn main() {
    let mut rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut rng, 1, 4);

    let mut indv1: Individual<SnakeTree> = Individual::new(&mut tree_gen);
    let mut indv2: Individual<SnakeTree> = Individual::new(&mut tree_gen);

    let mut rng = OsRng::new().unwrap();
    let crossover = Crossover::one_point();
    println!("---");
    println!("{}", indv1);
    println!("{}", indv2);
    println!("---");
    crossover.mate(&mut indv1, &mut indv2, &mut rng);
    println!("{}", indv1);
    println!("{}", indv2);
    println!("---");

    println!("{}", indv1);
    let mut mutate_rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut mutate_rng, 1, 2);
    let mutation = Mutation::uniform();
    mutation.mutate(&mut indv1, &mut tree_gen);
    println!("{}", indv1);

    let mut env = SnakeEnvironment {
        size: Vector { x: 10, y: 10 },
        food: Vector { x: 9, y: 9 },
        snake: vec![Vector { x: 3, y: 3 }, Vector { x: 4, y: 3 }],
    };

    for _ in 0..200 {
        let indv: Individual<SnakeTree> = Individual::new(&mut tree_gen);

        let mut score1 = 0;
        let mut score2 = 0;
        let mut tick = 100;
        while tick > 0 {
            //println!("{:?} {:?}", tick, env.snake);
            let move_ = indv.tree.evaluate(&env);
            if env.sense_danger(move_) {
                break;
            }
            if env.sense_food(move_) {
                score2 += 1;
                tick += 100;
                env.food = Vector {
                    x: rng.gen_range(0, 11),
                    y: rng.gen_range(0, 11),
                };
            }
            env.perform_movement(move_);
            score1 += 1;
            tick -= 1;
        }
        if score2 >= 1 {
            println!("lived={:?} ate={:?}", score1, score2);
            println!("{}", indv);
        }
    }
}

examples/symbolic_regression.rs (line 159)

fn main() {
    let mut rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut rng, 1, 4);

    let mut rng = OsRng::new().unwrap();
    let crossover = Crossover::one_point();

    let mut mutate_rng = OsRng::new().unwrap();
    let mut mut_tree_gen = TreeGen::full(&mut mutate_rng, 1, 2);
    let mutation = Mutation::uniform();

    let inputs: Vec<f64> = (-10..11).map(|i| (i as f64) / 10.0).collect();
    let expecteds: Vec<f64> = inputs.iter()
        .cloned()
        .map(|i| i.powi(4) + i.powi(3) + i.powi(2) + i)
        .collect();

    let mut population: Vec<Individual<Equation>> =
        (0..200).map(|_| Individual::new(&mut tree_gen)).collect();
    for round in 0..40 {
        let mut ranking = BinaryHeap::new();
        for individual in population.drain(..) {
            let mut sum_of_squared_errors = 0.0;
            for i in 0..inputs.len() {
                let input = inputs[i];
                let expected = expecteds[i];
                let output = individual.tree.evaluate(&input);
                let squared_error = (output - expected).powi(2);
                sum_of_squared_errors += squared_error;
            }
            if !sum_of_squared_errors.is_finite() {
                sum_of_squared_errors = 100000000000.0;
            }
            ranking.push(RankedIndividual(sum_of_squared_errors, individual));
        }

        let ranking = ranking.into_sorted_vec();
        //println!("{:?}", ranking);

        println!("=== ROUND {} ===", round);
        for i in 0..3 {
            println!("Rank {:?}\n  Range = [-1.0, 1.0]    Step = +0.1\n  Comparing to x^4 + x^3 \
                      + x^2 + x\n  Sum of squared error = {}\n  Equation = {}",
                     i,
                     ranking[i].0,
                     ranking[i].1);
        }

        for i in 0..100 {
            let RankedIndividual(_, mut indv1) = ranking[i].clone();
            let RankedIndividual(_, mut indv2) = ranking[i + 1].clone();

            population.push(indv1.clone());
            population.push(indv2.clone());

            crossover.mate(&mut indv1, &mut indv2, &mut rng);

            if rng.gen() {
                mutation.mutate(&mut indv1, &mut mut_tree_gen);
            }
            if rng.gen() {
                mutation.mutate(&mut indv2, &mut mut_tree_gen);
            }

            population.push(indv1);
            population.push(indv2);
        }

        println!();
    }
}

pub fn mutate<T, R>(&self, indv: &mut Individual<T>, tg: &mut TreeGen<'_, R>)

where T: Tree, R: Rng,

Mutate an individual according to the configured mutation mode.

Examples found in repository

examples/snake.rs (line 273)

fn main() {
    let mut rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut rng, 1, 4);

    let mut indv1: Individual<SnakeTree> = Individual::new(&mut tree_gen);
    let mut indv2: Individual<SnakeTree> = Individual::new(&mut tree_gen);

    let mut rng = OsRng::new().unwrap();
    let crossover = Crossover::one_point();
    println!("---");
    println!("{}", indv1);
    println!("{}", indv2);
    println!("---");
    crossover.mate(&mut indv1, &mut indv2, &mut rng);
    println!("{}", indv1);
    println!("{}", indv2);
    println!("---");

    println!("{}", indv1);
    let mut mutate_rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut mutate_rng, 1, 2);
    let mutation = Mutation::uniform();
    mutation.mutate(&mut indv1, &mut tree_gen);
    println!("{}", indv1);

    let mut env = SnakeEnvironment {
        size: Vector { x: 10, y: 10 },
        food: Vector { x: 9, y: 9 },
        snake: vec![Vector { x: 3, y: 3 }, Vector { x: 4, y: 3 }],
    };

    for _ in 0..200 {
        let indv: Individual<SnakeTree> = Individual::new(&mut tree_gen);

        let mut score1 = 0;
        let mut score2 = 0;
        let mut tick = 100;
        while tick > 0 {
            //println!("{:?} {:?}", tick, env.snake);
            let move_ = indv.tree.evaluate(&env);
            if env.sense_danger(move_) {
                break;
            }
            if env.sense_food(move_) {
                score2 += 1;
                tick += 100;
                env.food = Vector {
                    x: rng.gen_range(0, 11),
                    y: rng.gen_range(0, 11),
                };
            }
            env.perform_movement(move_);
            score1 += 1;
            tick -= 1;
        }
        if score2 >= 1 {
            println!("lived={:?} ate={:?}", score1, score2);
            println!("{}", indv);
        }
    }
}

examples/symbolic_regression.rs (line 208)

fn main() {
    let mut rng = OsRng::new().unwrap();
    let mut tree_gen = TreeGen::full(&mut rng, 1, 4);

    let mut rng = OsRng::new().unwrap();
    let crossover = Crossover::one_point();

    let mut mutate_rng = OsRng::new().unwrap();
    let mut mut_tree_gen = TreeGen::full(&mut mutate_rng, 1, 2);
    let mutation = Mutation::uniform();

    let inputs: Vec<f64> = (-10..11).map(|i| (i as f64) / 10.0).collect();
    let expecteds: Vec<f64> = inputs.iter()
        .cloned()
        .map(|i| i.powi(4) + i.powi(3) + i.powi(2) + i)
        .collect();

    let mut population: Vec<Individual<Equation>> =
        (0..200).map(|_| Individual::new(&mut tree_gen)).collect();
    for round in 0..40 {
        let mut ranking = BinaryHeap::new();
        for individual in population.drain(..) {
            let mut sum_of_squared_errors = 0.0;
            for i in 0..inputs.len() {
                let input = inputs[i];
                let expected = expecteds[i];
                let output = individual.tree.evaluate(&input);
                let squared_error = (output - expected).powi(2);
                sum_of_squared_errors += squared_error;
            }
            if !sum_of_squared_errors.is_finite() {
                sum_of_squared_errors = 100000000000.0;
            }
            ranking.push(RankedIndividual(sum_of_squared_errors, individual));
        }

        let ranking = ranking.into_sorted_vec();
        //println!("{:?}", ranking);

        println!("=== ROUND {} ===", round);
        for i in 0..3 {
            println!("Rank {:?}\n  Range = [-1.0, 1.0]    Step = +0.1\n  Comparing to x^4 + x^3 \
                      + x^2 + x\n  Sum of squared error = {}\n  Equation = {}",
                     i,
                     ranking[i].0,
                     ranking[i].1);
        }

        for i in 0..100 {
            let RankedIndividual(_, mut indv1) = ranking[i].clone();
            let RankedIndividual(_, mut indv2) = ranking[i + 1].clone();

            population.push(indv1.clone());
            population.push(indv2.clone());

            crossover.mate(&mut indv1, &mut indv2, &mut rng);

            if rng.gen() {
                mutation.mutate(&mut indv1, &mut mut_tree_gen);
            }
            if rng.gen() {
                mutation.mutate(&mut indv2, &mut mut_tree_gen);
            }

            population.push(indv1);
            population.push(indv2);
        }

        println!();
    }
}

Trait Implementations

impl Clone for Mutation

fn clone(&self) -> Mutation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mutation

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

Formats the value using the given formatter.

impl PartialEq for Mutation

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Mutation

impl StructuralPartialEq for Mutation