def bound3_precomputation(self, I, J):
i = I - self.i0
j = J - self.j0
if (i > self.bc) and (j > self.bc):
sub_x = self.x[i:]
sub_y = self.y[j:]
sub_problem = BnBWarping(
x=sub_x,
y=sub_y,
p=self.p,
depth=self.depth,
norm=self.norm,
root_node=(i, j),
bc=1,
plot_2d=self.plot_2d,
pvar_dist_mem=self.pvar_dist_mem,
cache_size=self.cache_size,
allow_randomization=self.allow_randomization,
min_step=self.min_step,
max_step=self.max_step)
return pybnb.Solver().solve(sub_problem,
log=None,
queue_strategy='depth').objective
return 0.
def bound3_precomputation(self, I, J):
i = I - self.i0
j = J - self.j0
if (i > self.bc) and (j > self.bc):
sub_x = self.x[i:]
sub_y = self.y[j:]
sub_problem = BnBWarping(x=sub_x,
y=sub_y,
p=self.p,
depth=self.depth,
norm=self.norm,
root_node=(i, j),
bc=1,
plot_2d=self.plot_2d,
record_path=False,
pvar_dist_mem=self.pvar_dist_mem,
pvar_mem_org=self.pvar_mem_org,
initial_time=self.initial_time,
use_bound1=self.use_bound1,
use_bound2=self.use_bound2,
use_bound3=self.use_bound3,
cache_size=self.cache_size)
return pybnb.Solver().solve(sub_problem,
log=None,
queue_strategy='depth').objective
return 0.
def roda_branch(string_a,string_b):
sng = Singleton()
sng.lst = None
problem = Simple(string_a, string_b)
solver = pybnb.Solver(comm=None)
results = solver.solve(problem)
return results.objective
def _test_heaps(comm):
solver = pybnb.Solver(comm=comm)
if comm is not None:
if comm.rank == 0:
pass
elif comm.rank == 1:
pass
elif comm.rank == 3:
pass
for heap in gen_heaps(2):
heap_bound = get_bound(heap)
node_list = [None, len(heap)] + [i for i in range(len(heap))
if heap[i] is not None]
# min
for default_objective in [None, 2]:
for objective_node in node_list:
if objective_node is not None:
problem = Discrete(pybnb.minimize,
{objective_node: 1},
heap,
default_objective=2)
else:
problem = Discrete(pybnb.minimize,
{},
heap,
default_objective=1)
results = solver.solve(problem, log=None)
if objective_node == len(heap):
assert results.objective == 2
else:
assert results.objective == 1
assert results.bound == heap_bound
# max
heap_bound = -heap_bound
heap = [-b_ if (b_ is not None) else None
for b_ in heap]
for default_objective in [None, 2]:
for objective_node in node_list:
if objective_node is not None:
problem = Discrete(pybnb.maximize,
{objective_node: -1},
heap,
default_objective=-2)
else:
problem = Discrete(pybnb.maximize,
{},
heap,
default_objective=-1)
results = solver.solve(problem, log=None)
if objective_node == len(heap):
assert results.objective == -2
else:
assert results.objective == -1
assert results.bound == heap_bound
def bound3_precomputation(self, I, J):
i = I - self.i0
j = J - self.j0
if (i > self.bc) and (j > self.bc):
sub_x = self.x[i:]
sub_y = self.y[j:]
sub_problem = BnBWarping(x=sub_x,
y=sub_y,
p=self.p,
depth=self.depth,
norm=self.norm,
root_node=(i, j),
bc=1,
plot_2d=self.plot_2d)
return pybnb.Solver(comm=None).solve(
sub_problem, log=None, queue_strategy='depth').objective
return 0.
idx = np.linspace(0, 4 * np.pi, 11)
x = np.sin(idx)
y = np.cos(idx)
x = AddTime().fit_transform([x])[0]
y = AddTime().fit_transform([y])[0]
problem = BnBWarping(x=x,
y=y,
p=1.5,
depth=2,
norm='l1',
root_node=(0, 0),
bc=4,
plot_2d=True)
solver = pybnb.Solver()
print(f'\n BnB algo is using {solver.worker_count} core/s')
results = solver.solve(problem, log=None, queue_strategy='depth')
print('warped p-var: {:.2f}'.format(results.objective))
print('wall time: {:.2f} secs \n \n'.format(results.wall_time))
#best_warp = results.best_node.state
#_, optimal_partition = problem.distance(results.best_node.state, optim_partition=True)
#problem.plot_alignment([best_warp[k] for k in optimal_partition])
#plt.show()
type=str,
default=None,
help=("When set, saves the solver results into a "
"YAML-formated file with the given name."))
args = parser.parse_args()
problem = Rosenbrock2D(xL=-25, xU=25, yL=-25, yU=25)
# do parallel bounds tightening on the
# first 7 nodes that are processed
obrr = Rosenbrock2D_RangeReduction(problem, comm=comm)
queue = None
best_node = None
if (comm is None) or (comm.rank == 0):
opt_obrr = pybnb.Solver(comm=None)
results = opt_obrr.solve(obrr, node_limit=7, log_interval_seconds=0)
queue = opt_obrr.save_dispatcher_queue()
best_node = results.best_node
else:
obrr.listen(root=0)
del obrr
# continue the solve in parallel, without bounds
# tightening on the remaining nodes
results = pybnb.solve(problem,
comm=comm,
relative_gap=1e-4,
dispatcher_rank=0,
best_node=best_node,
initialize_queue=queue,
def _test_heaps(comm):
solver = pybnb.Solver(comm=comm)
if comm is not None:
if comm.rank == 0:
pass
elif comm.rank == 1:
pass
elif comm.rank == 3:
pass
problem = SmallHeap()
results = solver.solve(problem, queue_strategy='breadth')
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == 0
assert results.bound == -2
assert results.best_node.objective == 0
assert results.best_node.bound == -1
assert results.best_node.state == 3
_uuid = results.best_node._uuid
queue = solver.save_dispatcher_queue()
if solver.is_dispatcher:
assert queue.bound() == -2
assert queue.worst_terminal_bound == -2
assert len(queue.nodes) == 0
results = solver.solve(problem,
initialize_queue=queue,
best_node=results.best_node)
assert results.solution_status == "feasible"
assert results.termination_condition == "queue_empty"
assert results.objective == 0
assert results.bound == -2
assert results.best_node.objective == 0
assert results.best_node.bound == -1
assert results.best_node.state == 3
assert results.best_node._uuid == _uuid
queue = solver.save_dispatcher_queue()
if solver.is_dispatcher:
assert queue.bound() == -2
assert queue.worst_terminal_bound == -2
assert len(queue.nodes) == 0
for heap in gen_heaps(2):
heap_bound = get_bound(heap)
node_list = [None, len(heap)] + \
[i for i in range(len(heap))
if heap[i] is not None]
# min
for objective_node in node_list:
if objective_node is not None:
problem = Discrete(pybnb.minimize, {objective_node: 1},
heap,
default_objective=2)
else:
problem = Discrete(pybnb.minimize, {},
heap,
default_objective=1)
results = solver.solve(problem, log=None)
if objective_node == len(heap):
assert results.objective == 2
else:
assert results.objective == 1
assert results.bound == heap_bound
# max
heap_bound = -heap_bound
heap = [-b_ if (b_ is not None) else None for b_ in heap]
for objective_node in node_list:
if objective_node is not None:
problem = Discrete(pybnb.maximize, {objective_node: -1},
heap,
default_objective=-2)
else:
problem = Discrete(pybnb.maximize, {},
heap,
default_objective=-1)
results = solver.solve(problem, log=None)
if objective_node == len(heap):
assert results.objective == -2
else:
assert results.objective == -1
assert results.bound == heap_bound
