for i in range(data_.shape[1]):
beam_labels_numpy[i * beam_width: (i + 1) * beam_width, :] = beam_labels[i]
# find expression from these predicted beam labels
expressions = [""] * config.batch_size * beam_width
for i in range(config.batch_size * beam_width):
for j in range(max_len):
expressions[i] += generator.unique_draw[beam_labels_numpy[i, j]]
for index, prog in enumerate(expressions):
expressions[index] = prog.split("$")[0]
#Predicted_expressions += expressions
target_expressions = parser.labels2exps(labels, k)
Target_expressions += target_expressions
target_stacks = parser.expression2stack(target_expressions)
target_voxels = target_stacks[-1,:,0,:,:,:].astype(dtype=bool)
target_voxels_new = np.repeat(target_voxels, axis=0,
repeats=beam_width)
predicted_stack = stack_from_expressions(parser, expressions)
beam_R = np.sum(np.logical_and(target_voxels_new, predicted_stack), (1, 2,
3)) / \
(np.sum(np.logical_or(target_voxels_new, predicted_stack), (1, 2,
3)) + 1)
axis = glm.vec3(1,1,1)
transfer_matrix = axis_view_matrix(axis=axis)
center = np.dot( transfer_matrix,np.array([32,32,32],dtype=float) )
# choose an output whose projection is the most similar to the input 2D image
expressions = [""] * test_batch_size * beam_width
for i in range(test_batch_size * beam_width):
for j in range(maxx_len):
expressions[i] += generator.unique_draw[beam_labels_numpy[
i, j]]
for index, p in enumerate(expressions):
expressions[index] = p.split("$")[0]
programs_tar[jit] += targ_prog
programs_pred[jit] += expressions
pred_images = []
for index, exp in enumerate(expressions):
program = parser.Parser.parse(exp)
if validity(program, len(program), len(program) - 1):
stack = parser.expression2stack([exp])
pred_images.append(stack[-1, -1, 0, :, :])
else:
pred_images.append(np.zeros(config.canvas_shape))
pred_images = np.stack(pred_images, 0).astype(dtype=np.bool)
target_images = data_[-1, :, 0, :, :].astype(dtype=bool)
# repeat the target_images beamwidth times
target_images_new = np.repeat(target_images,
axis=0,
repeats=beam_width)
beam_CD = chamfer(target_images_new, pred_images)
CD = np.zeros((test_batch_size, 1))
for r in range(test_batch_size):
CD[r, 0] = min(beam_CD[r * beam_width:(r + 1) * beam_width])
class Optimize:
"""
Post processing visually guided search using Powell optimizer.
"""
def __init__(self, query_expression, metric="iou", stack_size=7, steps=15):
"""
Post processing visually guided search.
:param query_expression: expression to be optimized
:param metric: metric to be minimized, like chamfer
:param stack_size: max stack size required in any program
:param steps: max tim step of any program
"""
self.parser = ParseModelOutput(canvas_shape=[64, 64],
stack_size=stack_size,
unique_draws=None,
steps=steps)
self.query_expression = query_expression
self.get_graph_structure(query_expression)
self.metric = metric
self.errors = []
def get_target_image(self, image: np.ndarray):
"""
Gets the target image.
:param image: target image
:return:
"""
self.target_image = image
def get_graph_structure(self, expression):
"""
returns the nodes (terminals) of the program
:param expression: input query expression
:return:
"""
program = self.parser.Parser.parse(expression)
self.graph_str = []
for p in program:
self.graph_str.append(p["value"])
def make_expression(self, x: np.ndarray):
expression = ""
index = 0
for e in self.graph_str:
if e in ["c", "s", "t"]:
expression += e + "({},{},{})".format(x[index], x[index + 1],
x[index + 2])
index += 3
else:
expression += e
return expression
def objective(self, x: np.ndarray):
"""
Objective to minimize.
:param x: input program parameters in numpy array format
:return:
"""
x = x.astype(np.int)
x = np.clip(x, 8, 56)
query_exp = self.make_expression(x)
query_image = self.parser.expression2stack([query_exp])[-1, 0, 0, :, :]
if self.metric == "iou":
error = -np.sum(np.logical_and(
self.target_image, query_image)) / np.sum(
np.logical_or(self.target_image, query_image))
elif self.metric == "chamfer":
error = chamfer(np.expand_dims(self.target_image, 0),
np.expand_dims(query_image, 0))
return error