def __init__(self, id_dds, dds, tolerance, collapse_threshold,
min_visibility, debug_it, max_it):
self.dds = dds
self.ds = DiffeoStructure(dds, tolerance)
collapse_metric = DiffeoActionL2iwNormalized(self.ds)
self.cover = DiffeoCoverExp(
id_dds=id_dds,
dds=self.dds,
plan_reducer=self.ds.get_plan_reducer(),
collapse_metric=collapse_metric,
# collapse_threshold=collapse_threshold,
collapse_threshold=0.001,
max_depth=3,
debug_iterations=debug_it,
max_iterations=max_it)
self.cover.set_min_visibility(min_visibility)
self.cover.go()
def __init__(self, id_dds, dds, tolerance,
collapse_threshold,
min_visibility, debug_it, max_it):
self.dds = dds
self.ds = DiffeoStructure(dds, tolerance)
collapse_metric = DiffeoActionL2iwNormalized(self.ds)
self.cover = DiffeoCoverExp(id_dds=id_dds,
dds=self.dds,
plan_reducer=self.ds.get_plan_reducer(),
collapse_metric=collapse_metric,
# collapse_threshold=collapse_threshold,
collapse_threshold=0.001,
max_depth=3,
debug_iterations=debug_it,
max_iterations=max_it)
self.cover.set_min_visibility(min_visibility)
self.cover.go()
class DiffeoSystemBounds2(object):
def __init__(self, id_dds, dds, tolerance, collapse_threshold,
min_visibility, debug_it, max_it):
self.dds = dds
self.ds = DiffeoStructure(dds, tolerance)
collapse_metric = DiffeoActionL2iwNormalized(self.ds)
self.cover = DiffeoCoverExp(
id_dds=id_dds,
dds=self.dds,
plan_reducer=self.ds.get_plan_reducer(),
collapse_metric=collapse_metric,
# collapse_threshold=collapse_threshold,
collapse_threshold=0.001,
max_depth=3,
debug_iterations=debug_it,
max_iterations=max_it)
self.cover.set_min_visibility(min_visibility)
self.cover.go()
#
# self.make_bases(self.dds, self.ds)
def make_bases(self, dds, ds):
n = len(dds.actions)
# # Create all combinations of n of all elements
# print('Creating all combinations of len %s' % n)
# bplans = plans_of_max_length(n, n)
# print('Created %d ' % len(bplans))
# minimal, mmap = ds.get_minimal_equiv_set(bplans)
# print('Minimal %d ' % len(minimal))
# # print minimal
# self.find_non_red_plans(nactions=n, length=3, threshold=0.05)
self.make_closure(nactions=n, length=3, threshold=0.05)
@dp_memoize_instance
def plan_distance_norm(self, plan1, plan2):
dn = self.cover.plan_distance(
plan1, plan2, diffeoaction_distance_L2_infow) / self.ds.scalew
return dn
def minimum_dist_to_set(self, plan, plans):
d = [self.plan_distance_norm(plan, p) for p in plans]
i = np.argmin(d)
return plans[i], min(d)
def plan_inverse(self, plan):
l = [
self.ds.plan_reducer.action_get_inverse(a) for a in reversed(plan)
]
return tuple(l)
def make_commutator(self, plan1, plan2):
com = plan1 + plan2 + self.plan_inverse(plan1) + self.plan_inverse(
plan2)
com = self.ds.plan_reducer.get_canonical(com)
return com
def make_closure(self, nactions, length, threshold):
if length == 1:
return [(a, ) for a in range(nactions)] + [()]
prev = self.make_closure(nactions, length - 1, threshold)
generated = []
for prev1, prev2 in itertools.product(prev, prev):
if prev1 == prev2:
continue
com = self.make_commutator(prev1, prev2)
# print('[%s, %s] -> %s ' % (prev1, prev2, com))
_, md = self.minimum_dist_to_set(com, prev + generated)
# print('%s md %s to %s' % (com, md, closest))
if md < threshold:
# print('%s matches %s' % (com, closest))
continue
else:
generated.append(com)
print('Length %d generated %d:' % (length, len(generated)))
for _, g in enumerate(generated):
print(' - %s' % str(g))
return generated + prev
def find_non_red_plans(self, nactions, length, threshold):
if length == 0:
return [()]
prev = self.find_non_red_plans(nactions, length - 1, threshold)
cur = []
cur.extend(prev)
for p0 in prev:
if len(p0) != length - 1:
# only build in those from the previous level
continue
for action in range(nactions):
if action in p0:
# no repeated actions
continue
p1 = p0 + (action, )
closest, md = self.minimum_dist_to_set(p1, cur)
print('%s md %s to %s' % (p1, md, closest))
if md < threshold:
print('%s matches %s' % (p1, closest))
continue
else:
cur.append(p1)
print('Of length %d, found: %s' % (length, len(cur)))
return cur
def display(self, report): # @UnusedVariable
with report.subsection('draw_graph') as r:
self.cover.draw_graph(r)
def display_products(self, report, nsteps):
for a in self.dds_hard.actions:
f = report.figure(a.label, cols=nsteps)
A = a
for k in range(nsteps):
A = DiffeoAction.compose(A, a)
rgb = A.get_diffeo2d_forward().get_rgb_info()
f.data_rgb('%s_%s' % (a.label, k), rgb)
class DiffeoSystemBounds2(object):
def __init__(self, id_dds, dds, tolerance,
collapse_threshold,
min_visibility, debug_it, max_it):
self.dds = dds
self.ds = DiffeoStructure(dds, tolerance)
collapse_metric = DiffeoActionL2iwNormalized(self.ds)
self.cover = DiffeoCoverExp(id_dds=id_dds,
dds=self.dds,
plan_reducer=self.ds.get_plan_reducer(),
collapse_metric=collapse_metric,
# collapse_threshold=collapse_threshold,
collapse_threshold=0.001,
max_depth=3,
debug_iterations=debug_it,
max_iterations=max_it)
self.cover.set_min_visibility(min_visibility)
self.cover.go()
#
# self.make_bases(self.dds, self.ds)
def make_bases(self, dds, ds):
n = len(dds.actions)
# # Create all combinations of n of all elements
# print('Creating all combinations of len %s' % n)
# bplans = plans_of_max_length(n, n)
# print('Created %d ' % len(bplans))
# minimal, mmap = ds.get_minimal_equiv_set(bplans)
# print('Minimal %d ' % len(minimal))
# # print minimal
# self.find_non_red_plans(nactions=n, length=3, threshold=0.05)
self.make_closure(nactions=n, length=3, threshold=0.05)
@dp_memoize_instance
def plan_distance_norm(self, plan1, plan2):
dn = self.cover.plan_distance(plan1, plan2, diffeoaction_distance_L2_infow) / self.ds.scalew
return dn
def minimum_dist_to_set(self, plan, plans):
d = [self.plan_distance_norm(plan, p) for p in plans]
i = np.argmin(d)
return plans[i], min(d)
def plan_inverse(self, plan):
l = [self.ds.plan_reducer.action_get_inverse(a) for a in reversed(plan)]
return tuple(l)
def make_commutator(self, plan1, plan2):
com = plan1 + plan2 + self.plan_inverse(plan1) + self.plan_inverse(plan2)
com = self.ds.plan_reducer.get_canonical(com)
return com
def make_closure(self, nactions, length, threshold):
if length == 1:
return [(a,) for a in range(nactions)] + [()]
prev = self.make_closure(nactions, length - 1, threshold)
generated = []
for prev1, prev2 in itertools.product(prev, prev):
if prev1 == prev2:
continue
com = self.make_commutator(prev1, prev2)
# print('[%s, %s] -> %s ' % (prev1, prev2, com))
_, md = self.minimum_dist_to_set(com, prev + generated)
# print('%s md %s to %s' % (com, md, closest))
if md < threshold:
# print('%s matches %s' % (com, closest))
continue
else:
generated.append(com)
print('Length %d generated %d:' % (length, len(generated)))
for _, g in enumerate(generated):
print(' - %s' % str(g))
return generated + prev
def find_non_red_plans(self, nactions, length, threshold):
if length == 0:
return [()]
prev = self.find_non_red_plans(nactions, length - 1, threshold)
cur = []
cur.extend(prev)
for p0 in prev:
if len(p0) != length - 1:
# only build in those from the previous level
continue
for action in range(nactions):
if action in p0:
# no repeated actions
continue
p1 = p0 + (action,)
closest, md = self.minimum_dist_to_set(p1, cur)
print('%s md %s to %s' % (p1, md, closest))
if md < threshold:
print('%s matches %s' % (p1, closest))
continue
else:
cur.append(p1)
print('Of length %d, found: %s' % (length, len(cur)))
return cur
def display(self, report): # @UnusedVariable
with report.subsection('draw_graph') as r:
self.cover.draw_graph(r)
def display_products(self, report, nsteps):
for a in self.dds_hard.actions:
f = report.figure(a.label, cols=nsteps)
A = a
for k in range(nsteps):
A = DiffeoAction.compose(A, a)
rgb = A.get_diffeo2d_forward().get_rgb_info()
f.data_rgb('%s_%s' % (a.label, k), rgb)
