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
use crate::problem::KurobakoProblemRecipe;
use crate::solver::KurobakoSolverRecipe;
use kurobako_core::json;
use kurobako_core::problem::{
Evaluator as _, Problem as _, ProblemFactory as _, ProblemRecipe as _,
};
use kurobako_core::registry::FactoryRegistry;
use kurobako_core::rng::ArcRng;
use kurobako_core::trial::{Params, Values};
use kurobako_core::{ErrorKind, Result};
use serde::{Deserialize, Serialize};
use structopt::StructOpt;
#[derive(Debug, Clone, StructOpt)]
#[structopt(rename_all = "kebab-case")]
pub struct EvaluateOpt {
#[structopt(long, parse(try_from_str = json::parse_json))]
pub problem: KurobakoProblemRecipe,
#[structopt(long, parse(try_from_str = json::parse_json))]
pub params: Params,
#[structopt(long)]
pub step: Option<u64>,
#[structopt(long)]
pub seed: Option<u64>,
}
impl EvaluateOpt {
pub fn evaluate(&self) -> Result<Evaluated> {
let random_seed = self.seed.unwrap_or_else(rand::random);
let rng = ArcRng::new(random_seed);
let registry = FactoryRegistry::new::<KurobakoProblemRecipe, KurobakoSolverRecipe>();
let problem_factory = track!(self.problem.create_factory(®istry))?;
let problem_spec = track!(problem_factory.specification())?;
track_assert_eq!(
self.params.len(),
problem_spec.params_domain.variables().len(),
ErrorKind::InvalidInput
);
let problem = track!(problem_factory.create_problem(rng))?;
let mut evaluator = track!(problem.create_evaluator(self.params.clone()))?;
let step = self.step.unwrap_or_else(|| problem_spec.steps.last());
let (current_step, values) = track!(evaluator.evaluate(step))?;
Ok(Evaluated {
values,
step: current_step,
seed: random_seed,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Evaluated {
pub values: Values,
pub step: u64,
pub seed: u64,
}