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
|
mod config;
mod corpus;
mod evaluation;
mod layout;
mod output;
use rayon::prelude::*;
use rand::prelude::*;
use rand_pcg::*;
use config::*;
use corpus::*;
use evaluation::*;
use layout::*;
use std::time::Instant;
struct Tournament<'a> {
rngs: Vec<Pcg64>,
top_prelayouts: Vec<(Prelayout, f32)>,
corpus: &'a Corpus,
}
impl<'a> Tournament<'a> {
fn new_from_seed_prelayout(seed_prelayout: &Prelayout, corpus: &'a Corpus) -> Tournament<'a> {
let mut rngs: Vec<Pcg64> = Vec::new();
for _ in 0..NUM_CONTESTANTS {
rngs.push(Pcg64::from_entropy());
}
let mut top_prelayouts: Vec<(Prelayout, f32)> = Vec::new();
let score = prelayout_fitness(&corpus, &seed_prelayout);
for _ in 0..NUM_PERSIST {
top_prelayouts.push((seed_prelayout.clone(), score));
}
Tournament {
rngs,
top_prelayouts,
corpus,
}
}
fn run_round(&mut self) -> Option<Prelayout> {
let rngs = &mut self.rngs;
let mut tournament = rngs
.into_par_iter()
.map(|mut rng| {
let layout = Prelayout::new_random_from(
&self.top_prelayouts[rng.gen_range(0..NUM_PERSIST)].0,
&mut rng,
);
return (layout, prelayout_fitness(&self.corpus, &layout));
})
.collect::<Vec<(Prelayout, f32)>>();
let best = self.top_prelayouts[0].1;
tournament.append(&mut self.top_prelayouts);
tournament.sort_by(|(_, lscore), (_, rscore)| {
if lscore < rscore {
std::cmp::Ordering::Less
} else {
std::cmp::Ordering::Greater
}
});
let result;
if tournament[0].1 + 1e-7 < best {
result = Some(tournament[0].0);
} else {
result = None;
}
for i in 0..NUM_PERSIST {
self.top_prelayouts.push(tournament[i]);
}
result
}
}
fn main() {
let corpus;
if LOAD_STATS {
corpus = Corpus::load_from_json_file(STATS_FILE_NAME).unwrap();
} else {
corpus = Corpus::load_from_text_file(CORPUS_FILE_NAME).unwrap();
}
println!("{}", corpus);
let seed_layout = Layout::from_verbose(STARTING_LAYOUT_STRING).unwrap();
let seed_evl = Evaluation::evaluate_layout(&corpus, &seed_layout);
let seed_prelayout = seed_layout.as_prelayout();
println!("Starting with\n{}{}", seed_layout, seed_evl);
let mut tournament = Tournament::new_from_seed_prelayout(&seed_prelayout, &corpus);
let mut count: usize = 0;
let mut current = Instant::now();
loop {
let improvement = tournament.run_round();
if let Some(prelayout) = improvement {
let layout = Layout::from_prelayout(&prelayout, &corpus);
let evl = Evaluation::evaluate_layout(&corpus, &layout);
println!("\n================================================================================\n\n{}{}",
layout, evl
);
}
count += 1;
if count > 65535 {
let duration = current.elapsed();
let rps = count as f32 / duration.as_millis() as f32 * 1000.0;
eprint!(
"\u{001b}[2K\u{001b}[1000D{} layouts/s and {} tournaments/s",
rps * NUM_CONTESTANTS as f32,
rps
);
current = Instant::now();
count = 0;
}
}
}
|
