[dependencies]
oxigen = "^2"

要使用 oxigen，请使用 use oxigen::prelude::* 并在一个 GeneticExecution 实例上调用 run 方法，覆盖默认的超参数和函数，以满足您的需求

let n_queens: u8 = std::env::args()
    .nth(1)
    .expect("Enter a number between 4 and 255 as argument")
    .parse()
    .expect("Enter a number between 4 and 255 as argument");

let progress_log = File::create("progress.csv").expect("Error creating progress log file");
let population_log = File::create("population.txt").expect("Error creating population log file");
let log2 = (f64::from(n_queens) * 4_f64).log2().ceil();

let population_size = 2_i32.pow(log2 as u32) as usize;

let (solutions, generation, progress) = GeneticExecution::<u8, QueensBoard>::new()
    .population_size(population_size)
    .genotype_size(n_queens as u8)
    .mutation_rate(Box::new(MutationRates::Linear(SlopeParams {
        start: f64::from(n_queens) / (8_f64 + 2_f64 * log2) / 100_f64,
        bound: 0.005,
        coefficient: -0.0002,
    })))
    .selection_rate(Box::new(SelectionRates::Linear(SlopeParams {
        start: log2 - 2_f64,
        bound: log2 / 1.5,
        coefficient: -0.0005,
    })))
    .select_function(Box::new(SelectionFunctions::Cup))
    .age_function(Box::new(AgeFunctions::Quadratic(
        AgeThreshold(50),
        AgeSlope(1_f64),
    )))
    .progress_log(20, progress_log)
    .population_log(2000, population_log)
    .run();

有关完整示例，请访问 nqueens-oxigen 示例。

有关更多信息，请访问 文档。

恢复之前的执行

从版本 1.1.0 开始，遗传算法执行会返回上一代的人口，新的遗传执行接受一个初始人口。这允许恢复之前的执行，并允许协同进化，因为可以在适应度函数中启动少量遗传算法的重新执行。

以下示例中启动了一个10000代的执行，并在找到解决方案后继续执行，以不同的速率。

let n_queens: u8 = std::env::args()
    .nth(1)
    .expect("Enter a number between 4 and 255 as argument")
    .parse()
    .expect("Enter a number between 4 and 255 as argument");

let progress_log = File::create("progress.csv").expect("Error creating progress log file");
let population_log = File::create("population.txt").expect("Error creating population log file");
let log2 = (f64::from(n_queens) * 4_f64).log2().ceil();

let population_size = 2_i32.pow(log2 as u32) as usize;

let (_solutions, _generation, _progress, population) = GeneticExecution::<u8, QueensBoard>::new()
    .population_size(population_size)
    .genotype_size(n_queens as u8)
    .mutation_rate(Box::new(MutationRates::Linear(SlopeParams {
        start: f64::from(n_queens) / (8_f64 + 2_f64 * log2) / 100_f64,
        bound: 0.005,
        coefficient: -0.0002,
    })))
    .selection_rate(Box::new(SelectionRates::Linear(SlopeParams {
        start: log2 - 2_f64,
        bound: log2 / 1.5,
        coefficient: -0.0005,
    })))
    .select_function(Box::new(SelectionFunctions::Cup))
    .age_function(Box::new(AgeFunctions::Quadratic(
        AgeThreshold(50),
        AgeSlope(1_f64),
    )))
    .stop_criterion(Box::new(StopCriteria::Generation(10000)))
    .run();

let (solutions, generation, progress, _population) = GeneticExecution::<u8, QueensBoard>::new()
    .population_size(population_size)
    .genotype_size(n_queens as u8)
    .mutation_rate(Box::new(MutationRates::Linear(SlopeParams {
        start: f64::from(n_queens) / (8_f64 + 4_f64 * log2) / 100_f64,
        bound: 0.005,
        coefficient: -0.0002,
    })))
    .selection_rate(Box::new(SelectionRates::Linear(SlopeParams {
        start: log2 - 4_f64,
        bound: log2 / 1.5,
        coefficient: -0.0005,
    })))
    .select_function(Box::new(SelectionFunctions::Cup))
    .age_function(Box::new(AgeFunctions::Quadratic(
        AgeThreshold(50),
        AgeSlope(1_f64),
    )))
    .population(population)
    .progress_log(20, progress_log)
    .population_log(2000, population_log)
    .run();

构建

要构建 oxigen，请使用 cargo，就像任何 Rust 项目一样

• cargo build 以调试模式构建。
• cargo build --release 以优化方式构建。

要运行基准测试，您需要一个 nightly Rust 编译器。取消注释 // #![feature(test)] 和 // mod benchmarks; 从 lib.rs，然后可以使用 cargo bench 运行基准测试。

基准测试

以下基准测试已创建，用于测量遗传算法函数的性能

running 25 tests
test benchmarks::bench_cross_multi_point_255inds                                                           ... bench:     348,371 ns/iter (+/- 10,506)
test benchmarks::bench_cross_single_point_255inds                                                          ... bench:     113,986 ns/iter (+/- 10,657)
test benchmarks::bench_cross_uniform_255inds                                                               ... bench:      88,426 ns/iter (+/- 2,302)
test benchmarks::bench_distance_255                                                                        ... bench:      20,715 ns/iter (+/- 1,648)
test benchmarks::bench_fitness_1024inds                                                                    ... bench:     377,344 ns/iter (+/- 8,617)
test benchmarks::bench_fitness_age_1024inds                                                                ... bench:      31,360 ns/iter (+/- 1,204)
test benchmarks::bench_get_fitnesses_1024inds                                                              ... bench:      18,951 ns/iter (+/- 868)
test benchmarks::bench_get_solutions_1024inds                                                              ... bench:      30,133 ns/iter (+/- 1,612)
test benchmarks::bench_mutation_1024inds                                                                   ... bench:          13 ns/iter (+/- 0)
test benchmarks::bench_not_cached_fitness_1024inds                                                         ... bench:     373,966 ns/iter (+/- 60,244)
test benchmarks::bench_not_cached_fitness_age_1024inds                                                     ... bench:     395,056 ns/iter (+/- 24,407)
test benchmarks::bench_selection_cup_255inds                                                               ... bench:     344,873 ns/iter (+/- 40,519)
test benchmarks::bench_selection_roulette_256inds                                                          ... bench:     140,994 ns/iter (+/- 1,294)
test benchmarks::bench_selection_tournaments_256inds                                                       ... bench:     420,272 ns/iter (+/- 49,178)
test benchmarks::bench_survival_pressure_children_fight_most_similar_255inds                               ... bench:  14,948,961 ns/iter (+/- 989,864)
test benchmarks::bench_survival_pressure_children_fight_parents_255inds                                    ... bench:     108,691 ns/iter (+/- 157)
test benchmarks::bench_survival_pressure_children_replace_most_similar_255inds                             ... bench:  14,935,080 ns/iter (+/- 1,221,611)
test benchmarks::bench_survival_pressure_children_replace_parents_255inds                                  ... bench:     167,392 ns/iter (+/- 15,839)
test benchmarks::bench_survival_pressure_children_replace_parents_and_the_rest_most_similar_255inds        ... bench: 737,347,573 ns/iter (+/- 16,773,890)
test benchmarks::bench_survival_pressure_children_replace_parents_and_the_rest_random_most_similar_255inds ... bench:   7,757,258 ns/iter (+/- 612,047)
test benchmarks::bench_survival_pressure_competitive_overpopulation_255inds                                ... bench:  10,727,219 ns/iter (+/- 770,681)
test benchmarks::bench_survival_pressure_deterministic_overpopulation_255inds                              ... bench:     173,745 ns/iter (+/- 609)
test benchmarks::bench_survival_pressure_overpopulation_255inds                                            ... bench:  10,710,336 ns/iter (+/- 657,369)
test benchmarks::bench_survival_pressure_worst_255inds                                                     ... bench:      20,318 ns/iter (+/- 298)
test benchmarks::bench_update_progress_1024inds                                                            ... bench:       7,424 ns/iter (+/- 273)

这些基准测试在一个 Intel Core i7 6700K、16 GB DDR4 和 512 GB 三星 950 Pro NVMe SSD（ext4 格式）的 Fedora 30 系统上，使用 Linux 内核 5.2.9 执行。

不同适应度基准测试之间的性能差异有以下解释

• bench_fitness 测量缓存执行的性能，在每次基准测试迭代后清理适应度。这种清理是比未缓存基准测试慢的原因。
• bench_fitness_age 测量在所有基准测试迭代中缓存适应度的性能，因此它非常快。
• 未缓存的基准测试测量未缓存的执行性能，在最后一种情况下，有 1 代个体，因此性能相似，但必须应用年龄不适应度功能的基准测试要慢一些。
• children_fight_most_similar 和 children_replace_most_similar 函数需要调用距离函数 c * p 次，其中 c 是子代数量，p 是种群大小（基准测试中分别为 255 和 1024）。
• overpopulation 和 competitive_overpopulation 函数与 children_replace_most_similar 和 children_fight_most_similar 类似，只是它们只与种群中的 m 个个体进行比较（m 大于子代数量，小于种群大小，基准测试中为 768）。因此，与 children_replace_most_similar 和 children_fight_most_similar 相比，这些基准测试中有 3/4 的比较是在这些基准测试中完成的。
• children_replace_parents_and_the_rest_random_most_similar 与 children_replace_parents 类似，但在其后，随机选择个体与种群中最相似的个体进行对抗，直到种群大小恢复到原始大小。这意味着在整个种群中，根据每一代的重复父代进行0到254次随机选择和距离计算。
• children_replace_parents_and_the_rest_most_similar 类似于前面的函数，但它搜索种群中最相似的个体对，这意味着需要进行 p² 次距离函数调用（基准测试中为 2²⁰ 次）。

贡献

我们绝对欢迎并鼓励贡献！贡献可以有多种形式。您可以

1. 通过 issue 提交功能请求或错误报告。
2. 通过 issue 要求改进文档。
3. 对需要反馈的问题进行评论。
4. 通过 pull requests 贡献代码，提交 PR 之前别忘了运行 cargo fmt！

我们旨在保持 Rocket 代码的质量处于最高水平。这意味着您贡献的任何代码都必须是

• 注释：公共项必须进行注释。
• 文档化：公开的项必须有 rustdoc 注释，如有适用，需包含示例。
• 格式化：尽可能将您的代码格式化为 rustfmt。
• 简单：您的代码应尽可能简单且符合惯例地完成任务。
• 测试：当可能时，您应添加（并通过）任何您添加的功能的令人信服的测试。
• 专注：您的代码应仅执行其应执行的任务。

请注意，除非您明确声明，否则您提交给 oxigen 的任何有意贡献将根据 MIT 许可证和 Apache 许可证版本 2.0 双重许可，不附加任何额外条款或条件。

参考

Pozo, M.M. "Oxigen：使用 Rust 编写的快速、并行、可扩展和适应性强的遗传算法库"。

Bibtex

@misc{
  title={Oxigen: Fast, parallel, extensible and adaptable genetic algorithm library written in Rust},
  author={Pozo M.M.},
  howpublised = "\url{https://github.com/Martin1887/oxigen}"
}

许可证

oxigen 根据 Mozilla 公共许可证 2.0 许可。