def iterated_neighborhood(self, graph):
"""iterated_neighborhood."""
n = self.n_neigh_steps
if n == 1:
return pipe(graph, self.neighborhood, self._random_sample)
else:
return last(islice(iterate(self.set_neighborhood, [graph]), n + 1))
def optimize(self, reference_graphs):
"""Optimize iteratively."""
assert (self.grammar.is_fit())
assert (self.multiobj_est.is_fit())
seed_graph = self._init_pareto(reference_graphs)
# iterate
last(islice(iterate(self._update_pareto_set, seed_graph), self.n_iter))
graphs = self.pareto_set
return self._rank(graphs)
def sample(self, reference_graphs):
"""Optimize iteratively."""
# setup
#iteration_step_ = curry(self._iteration_step)(
# self.grammar, self.cost_estimator, self.max_neighborhood_order)
iteration_step_ = lambda x: self._iteration_step(
self.grammar, self.cost_estimator, self.max_neighborhood_order, x)
state_dict = dict()
state_dict['visited'] = set()
n_neigh_steps = 1
start_graphs = self.grammar.set_neighborhood(reference_graphs)
costs = self.cost_estimator.compute(start_graphs)
state_dict['pareto_set'] = get_pareto_set(start_graphs, costs)
seed_graph = random.choice(state_dict['pareto_set'])
arg = (seed_graph, state_dict, n_neigh_steps)
# iterate
arg = last(islice(iterate(iteration_step_, arg), self.max_n_iter))
seed_graph, state_dict, n_neigh_steps = arg
pareto_set_graphs = state_dict['pareto_set']
return pareto_set_graphs
def test_iterate():
assert list(itertools.islice(iterate(inc, 0), 0, 5)) == [0, 1, 2, 3, 4]
assert list(take(4, iterate(double, 1))) == [1, 2, 4, 8]
def compute_fuel_mass(mass):
return sum(
drop(
1,
takewhile(lambda x: x > 0, iterate(lambda m: floor(m / 3) - 2,
mass))))
def gap_fill_ref(original_ref, new_ref, pileup_positions, offs, off_pos, off):
raw_missings = set(xrange(1, len(original_ref)+1)) - set(pileup_positions)
missings = reduce(drop_gaps_because_insertion_offsets, izip(offs, off_pos), raw_missings)
gap_filled = reduce(insert_gap, imap(lambda x: x - 1, missings), new_ref)
return nth(off, iterate(lambda s: s[:-1] if s[-1] == '-' else s, gap_filled))
def generate_map_data(problem, x0, t, params):
f = problem(params)
x = take(iterate(f, x0), t + 1)
x = np.array(x)
return x[:-1], x[1:]
