def run_prob_anlg_tran_3x2_and_3x2(prob, anlg, tran):
b1_to_b2_x = None
b1_to_b2_y = None
diff_to_b3_x = None
diff_to_b3_y = None
diff_to_b2_x = None
diff_to_b2_y = None
diff = None
b1 = prob.matrix[anlg.get("value")[0]]
b2 = prob.matrix[anlg.get("value")[1]]
b3 = prob.matrix[anlg.get("value")[2]]
if "inv_unite" == tran.get("name"):
b1_new, _, _, _, _ = transform.apply_binary_transformation(
b2, b3, transform.get_tran("unite"), imgC=b1)
score, _, _ = jaccard.jaccard_coef(b1_new, b1)
elif "preserving_subtract_diff" == tran.get("name"):
b2_aj = asymmetric_jaccard.asymmetric_jaccard_coef(b1, b2)
b3_aj = asymmetric_jaccard.asymmetric_jaccard_coef(b1, b3)
preserving_score = min(b2_aj[0], b3_aj[0])
score, diff_to_b3_x, diff_to_b3_y, diff_to_b2_x, diff_to_b2_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(b3, b2)
if preserving_score < 0.85:
score = 0
else:
b1_b2_t, b1_to_b2_x, b1_to_b2_y, _, _ = transform.apply_binary_transformation(
b1, b2, tran, imgC=b3)
score, _, _ = jaccard.jaccard_coef(b1_b2_t, b3)
if "inv_unite" == tran.get("name"):
b2_score, _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(
b2, b3)
b3_score, _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(
b3, b2)
if max(b2_score, b3_score) > 0.9:
score = 0
if "unite" == tran.get("name") or "shadow_mask_unite" == tran.get("name"):
b1_score, _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(
b1, b2)
b2_score, _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(
b2, b1)
if max(b1_score,
b2_score) > 0.9: # if b1 is almost a subset of b2 or vice versa
score = 0
prob_anlg_tran_d = assemble_prob_anlg_tran_d(prob,
anlg,
tran,
score,
b1_to_b2_x=b1_to_b2_x,
b1_to_b2_y=b1_to_b2_y,
diff_to_b3_x=diff_to_b3_x,
diff_to_b3_y=diff_to_b3_y,
diff_to_b2_x=diff_to_b2_x,
diff_to_b2_y=diff_to_b2_y,
diff=diff)
return prob_anlg_tran_d
def predict_xor_diff(prob, anlg, tran, d):
best_diff_to_u1_x = d.get("diff_to_u1_x")
best_diff_to_u1_y = d.get("diff_to_u1_y")
best_diff = d.get("diff")
u3 = prob.matrix[anlg.get("value")[2]]
u1_ref = prob.matrix_ref[anlg.get("value")[0]]
prediction = transform.xor_diff(u3, best_diff_to_u1_x, best_diff_to_u1_y,
best_diff, u1_ref)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
pred_score, _, _ = jaccard.jaccard_coef(prediction, opt)
u3_score, u3_to_opt_x, u3_to_opt_y = jaccard.jaccard_coef(u3, opt)
u3_score = 1 - u3_score
u1_aligned, u2_aligned, aligned_to_u2_x, aligned_to_u2_y = utils.align(
u3, opt, u3_to_opt_x, u3_to_opt_y)
diff = utils.erase_noise_point(np.logical_xor(u1_aligned, u2_aligned),
4)
diff_score, _, _ = jaccard.jaccard_coef(diff, best_diff)
score = (diff_score + u3_score + pred_score) / 3
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def predict_subtract_diff(prob, anlg, tran, d):
best_diff_to_u1_x = d.get("diff_to_u1_x")
best_diff_to_u1_y = d.get("diff_to_u1_y")
best_diff_to_u2_x = d.get("diff_to_u2_x")
best_diff_to_u2_y = d.get("diff_to_u2_y")
best_diff = d.get("diff")
u3 = prob.matrix[anlg.get("value")[2]]
u1_ref = prob.matrix_ref[anlg.get("value")[0]]
prediction, best_diff_to_prediction_x, best_diff_to_prediction_y = transform.subtract_diff(
u3,
best_diff_to_u1_x,
best_diff_to_u1_y,
best_diff,
u1_ref,
coords=True)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
u3_score, diff_to_opt_x, diff_to_opt_y, diff_to_u3_x, diff_to_u3_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(opt, u3)
opt_to_u3_x = (-diff_to_opt_x) - (-diff_to_u3_x)
opt_to_u3_y = (-diff_to_opt_y) - (-diff_to_u3_y)
u2_to_u1_x = (-best_diff_to_u2_x) - (-best_diff_to_u1_x)
u2_to_u1_y = (-best_diff_to_u2_y) - (-best_diff_to_u1_y)
if abs(opt_to_u3_x - u2_to_u1_x) > 2 or abs(opt_to_u3_y -
u2_to_u1_y) > 2:
u3_score, diff = asymmetric_jaccard.asymmetric_jaccard_coef_pos_fixed(
opt, u3, u2_to_u1_x, u2_to_u1_y)
diff_score, _, _ = jaccard.jaccard_coef(diff, best_diff)
opt_score, _, _ = jaccard.jaccard_coef(prediction, opt)
# prediction_to_opt_x = -to_pred_x + to_opt_x
# prediction_to_opt_y = -to_pred_y + to_opt_y
#
# best_diff_to_opt_x = best_diff_to_prediction_x + prediction_to_opt_x
# best_diff_to_opt_y = best_diff_to_prediction_y + prediction_to_opt_y
# best_diff_aligned, opt_aligned, _, _ = utils.align(best_diff, opt, best_diff_to_opt_x, best_diff_to_opt_y)
# u3_restored = utils.trim_binary_image(np.logical_or(best_diff_aligned, opt_aligned))
# u3_restored_score , _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(u3, u3_restored)
score = (diff_score + u3_score + opt_score) / 3
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def predict_preserving_subtract_diff(prob, anlg, tran, d):
best_diff_to_b2_x = d.get("diff_to_b2_x")
best_diff_to_b2_y = d.get("diff_to_b2_y")
best_diff_to_b3_x = d.get("diff_to_b3_x")
best_diff_to_b3_y = d.get("diff_to_b3_y")
best_diff = d.get("diff")
b4 = prob.matrix[anlg.get("value")[3]]
b5 = prob.matrix[anlg.get("value")[4]]
b2_ref = prob.matrix_ref[anlg.get("value")[0]]
prediction, best_diff_to_prediction_x, best_diff_to_prediction_y = transform.subtract_diff(
b5,
best_diff_to_b2_x,
best_diff_to_b2_y,
best_diff,
b2_ref,
coords=True)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
b5_score, diff_to_opt_x, diff_to_opt_y, diff_to_b5_x, diff_to_b5_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(opt, b5)
opt_to_b5_x = (-diff_to_opt_x) - (-diff_to_b5_x)
opt_to_b5_y = (-diff_to_opt_y) - (-diff_to_b5_y)
b3_to_b2_x = (-best_diff_to_b3_x) - (-best_diff_to_b2_x)
b3_to_b2_y = (-best_diff_to_b3_y) - (-best_diff_to_b2_y)
if abs(opt_to_b5_x - b3_to_b2_x) > 2 or abs(opt_to_b5_y -
b3_to_b2_y) > 2:
b5_score, diff = asymmetric_jaccard.asymmetric_jaccard_coef_pos_fixed(
opt, b5, b3_to_b2_x, b3_to_b2_y)
diff_score, _, _ = jaccard.jaccard_coef(diff, best_diff)
opt_score, _, _ = jaccard.jaccard_coef(prediction, opt)
b4_b5_aj = asymmetric_jaccard.asymmetric_jaccard_coef(b4, b5)
b4_opt_aj = asymmetric_jaccard.asymmetric_jaccard_coef(b4, opt)
preserving_score = min(b4_b5_aj[0], b4_opt_aj[0])
score = (diff_score + b5_score + diff_score + preserving_score) / 4
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def predict_inv_unite(prob, anlg, tran, d):
b4 = prob.matrix[anlg.get("value")[3]]
b5 = prob.matrix[anlg.get("value")[4]]
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
# prediction = transform.inv_unite(b4, b5, opt)
# score, _, _ = jaccard.jaccard_coef(opt, prediction)
b4_new, _, _, _, _ = transform.apply_binary_transformation(
b5, opt, transform.get_tran("unite"), imgC=b4)
score, _, _ = jaccard.jaccard_coef(b4_new, b4)
b5_score, _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(
b5, opt)
opt_score, _, _, _, _, _ = asymmetric_jaccard.asymmetric_jaccard_coef(
opt, b5)
if max(b5_score, opt_score) > 0.85:
score = 0
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": opt
})
return pred_data
def jaccard_map(A_coms, B_coms):
"""
find a injective (not necessarily surjective, bijective or well-defined) mapping
between A_coms and B_coms such that the sum of jaccard indices of each mapped pair
of components is maximized
:param A_coms:
:param B_coms:
:return: indices of mapped pair, and minimal jaccard index
"""
all_jc = np.array(
[[jaccard.jaccard_coef(A_com, B_com)[0] for B_com in B_coms]
for A_com in A_coms])
thresholds = np.unique(all_jc)
max_mapping = None
max_mapping_t = None
max_mapping_size = -np.inf
for t in thresholds:
mapping = all_jc >= t
if utils.is_injective(mapping):
mapping_size = mapping.sum()
if mapping_size >= max_mapping_size:
max_mapping_size = mapping_size
max_mapping = mapping
max_mapping_t = t
if max_mapping is not None:
mapping_ids = np.where(max_mapping)
return mapping_ids[0].tolist(), mapping_ids[1].tolist(), max_mapping_t
else:
return [], [], 0
def evaluate_rearrange(u1, u2):
u1_coms, u1_coms_x, u1_coms_y = utils.decompose(u1, 8)
u2_coms, u2_coms_x, u2_coms_y = utils.decompose(u2, 8)
if len(u1_coms) != len(u2_coms):
return 0, [], [], [], []
max_scores = []
max_ids = []
chosen = [False] * len(u2_coms)
for u1_com in u1_coms:
max_score = -1
max_id = -1
for id, u2_com in enumerate(u2_coms):
if not chosen[id]:
score, _, _ = jaccard.jaccard_coef(u1_com, u2_com)
if score > max_score:
max_score = score
max_id = id
max_scores.append(max_score)
max_ids.append(max_id)
chosen[max_id] = True
min_max_score = min(max_scores)
if min_max_score < 0.6:
return 0, [], [], [], []
else:
u2_coms_x = [u2_coms_x[id] for id in max_ids]
u2_coms_y = [u2_coms_y[id] for id in max_ids]
return min_max_score, u1_coms_x, u1_coms_y, u2_coms_x, u2_coms_y
def inv_unite(A, B, C):
_, B_to_A_x, B_to_A_y = jaccard.jaccard_coef(B, A)
_, C_to_A_x, C_to_A_y = jaccard.jaccard_coef(C, A)
B_to_C_x = B_to_A_x - C_to_A_x
B_to_C_y = B_to_A_y - C_to_A_y
B_aligned, C_aligned, aligned_to_C_x, aligned_to_C_y = utils.align(
B, C, B_to_C_x, B_to_C_y)
B_new = np.logical_and(B_aligned, np.logical_not(C_aligned))
aligned_to_A_x = aligned_to_C_x + C_to_A_x
aligned_to_A_y = aligned_to_C_y + C_to_A_y
A_aligned, B_aligned, _, _ = utils.align(A, B_new, -aligned_to_A_x,
-aligned_to_A_y)
C_new = np.logical_and(A_aligned, np.logical_not(B_aligned))
C_new = utils.trim_binary_image(utils.erase_noise_point(C_new, 8))
return C_new
def predict_add_diff(prob, anlg, tran, d):
best_diff_to_u1_x = d.get("diff_to_u1_x")
best_diff_to_u1_y = d.get("diff_to_u1_y")
best_diff_to_u2_x = d.get("diff_to_u2_x")
best_diff_to_u2_y = d.get("diff_to_u2_y")
best_diff = d.get("diff")
u3 = prob.matrix[anlg.get("value")[2]]
u1_ref = prob.matrix_ref[anlg.get("value")[0]]
prediction = transform.add_diff(u3, best_diff_to_u1_x, best_diff_to_u1_y,
best_diff, u1_ref)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
u3_score, diff_to_u3_x, diff_to_u3_y, diff_to_opt_x, diff_to_opt_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(u3, opt)
u3_to_opt_x = (-diff_to_u3_x) - (-diff_to_opt_x)
u3_to_opt_y = (-diff_to_u3_y) - (-diff_to_opt_y)
u1_to_u2_x = (-best_diff_to_u1_x) - (-best_diff_to_u2_x)
u1_to_u2_y = (-best_diff_to_u1_y) - (-best_diff_to_u2_y)
if abs(u3_to_opt_x - u1_to_u2_x) > 2 or abs(u3_to_opt_y -
u1_to_u2_y) > 2:
u3_score, diff = asymmetric_jaccard.asymmetric_jaccard_coef_pos_fixed(
u3, opt, u1_to_u2_x, u1_to_u2_y)
diff_score, _, _ = jaccard.jaccard_coef(diff, best_diff)
opt_score, _, _ = jaccard.jaccard_coef(opt, prediction)
score = (diff_score + opt_score + u3_score) / 3
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def add_diff(img, diff_to_ref_x, diff_to_ref_y, diff, ref):
"""
:param img:
:param diff_to_ref_x:
:param diff_to_ref_y:
:param diff:
:param ref:
:return:
"""
if 0 == diff.sum():
return img
iimg = img.copy()
iimg_to_img_x = 0
iimg_to_img_y = 0
while True:
_, ref_to_iimg_x, ref_to_iimg_y = jaccard.jaccard_coef(ref, iimg)
diff_to_iimg_x = diff_to_ref_x + ref_to_iimg_x
diff_to_iimg_y = diff_to_ref_y + ref_to_iimg_y
score, _ = asymmetric_jaccard.asymmetric_jaccard_coef_pos_fixed(
diff, iimg, diff_to_iimg_x, diff_to_iimg_y)
if score > 0.9:
ref_aligned, iimg_aligned, aligned_to_iimg_x, aligned_to_iimg_y = utils.align(
ref, iimg, ref_to_iimg_x, ref_to_iimg_y)
iimg_aligned = utils.erase_noise_point(
np.logical_and(iimg_aligned, np.logical_not(ref_aligned)), 4)
iimg = iimg_aligned
iimg_to_img_x = aligned_to_iimg_x + iimg_to_img_x
iimg_to_img_y = aligned_to_iimg_y + iimg_to_img_y
if iimg.sum() == 0:
return img
else:
break
diff_to_img_x = diff_to_iimg_x + iimg_to_img_x
diff_to_img_y = diff_to_iimg_y + iimg_to_img_x
diff_aligned, img_aligned, _, _ = utils.align(diff, img, diff_to_img_x,
diff_to_img_y)
return utils.trim_binary_image(np.logical_or(img_aligned, diff_aligned))
def predict_unary_default(prob, anlg, tran, d):
u3 = prob.matrix[anlg.get("value")[2]]
prediction = transform.apply_unary_transformation(u3, tran)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
score, _, _ = jaccard.jaccard_coef(opt, prediction)
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def shadow_mask_unite(A, B):
shadow_A = utils.fill_holes(A)
shadow_B = utils.fill_holes(B)
score, shadow_A_to_B_x, shadow_A_to_B_y = jaccard.jaccard_coef(A, B)
shadow_A_aligned, shadow_B_aligned, _, _ = utils.align(
shadow_A, shadow_B, shadow_A_to_B_x, shadow_A_to_B_y)
mask = np.logical_and(shadow_A_aligned, shadow_B_aligned)
A_aligned, B_aligned, _, _ = utils.align(A, B, shadow_A_to_B_x,
shadow_A_to_B_y)
union = np.logical_or(A_aligned, B_aligned)
masked_union = np.logical_and(mask, union)
return utils.trim_binary_image(masked_union)
def predict_binary_default(prob, anlg, tran, d):
b4 = prob.matrix[anlg.get("value")[3]]
b5 = prob.matrix[anlg.get("value")[4]]
prediction, _, _, _, _ = transform.apply_binary_transformation(
b4, b5, tran)
pred_data = []
for ii, opt in enumerate(prob.options):
score, _, _ = jaccard.jaccard_coef(opt, prediction)
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def predict_duplicate(prob, anlg, tran, d):
best_copies_to_u1_x = d.get("copies_to_u1_x")
best_copies_to_u1_y = d.get("copies_to_u1_y")
u3 = prob.matrix[anlg.get("value")[2]]
prediction = transform.duplicate(u3, best_copies_to_u1_x,
best_copies_to_u1_y)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
score, _, _ = jaccard.jaccard_coef(opt, prediction)
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def standardize(coms):
coms_ref = []
for com in coms:
coms_ref.append(utils.fill_holes(com))
min_sim = np.inf
for A in coms_ref:
for B in coms_ref:
if 0 == A.sum() or 0 == B.sum():
continue
sim, _, _ = jaccard.jaccard_coef(A, B)
if sim < min_sim:
min_sim = sim
if min_sim > 0.85:
coms = utils.resize_to_average_shape(coms)
coms_ref = [np.full_like(coms[0], fill_value=True)] * len(coms)
return coms, coms_ref
else:
return coms, coms
def xor_diff(img, diff_to_ref_x, diff_to_ref_y, diff, ref):
"""
:param img:
:param diff_to_ref_x:
:param diff_to_ref_y:
:param diff:
:param ref:
:return:
"""
if 0 == diff.sum():
return img
_, img_to_ref_x, img_to_ref_y = jaccard.jaccard_coef(img, ref)
diff_to_img_x = diff_to_ref_x - img_to_ref_x
diff_to_img_y = diff_to_ref_y - img_to_ref_y
diff_aligned, img_aligned, _, _ = utils.align(diff, img, diff_to_img_x,
diff_to_img_y)
return utils.erase_noise_point(
utils.trim_binary_image(np.logical_xor(img_aligned, diff_aligned)), 4)
def predict_rearrange(prob, anlg, tran, d):
u1_coms_x = d.get("u1_coms_x")
u1_coms_y = d.get("u1_coms_y")
u2_coms_x = d.get("u2_coms_x")
u2_coms_y = d.get("u2_coms_y")
u3 = prob.matrix[anlg.get("value")[2]]
prediction = transform.rearrange(u3, u1_coms_x, u1_coms_y, u2_coms_x,
u2_coms_y)
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
score, _, _ = jaccard.jaccard_coef(opt, prediction)
pred_data.append({
**d, "optn": ii + 1,
"optn_score": score,
"mato_score": (d.get("mat_score") + score) / 2,
"pred": prediction
})
return pred_data
def apply_binary_transformation(imgA,
imgB,
tran,
imgA_to_imgB_x=None,
imgA_to_imgB_y=None,
imgC=None):
if imgA_to_imgB_x is None or imgA_to_imgB_y is None:
align_foo_name = tran.get("align")
if align_foo_name is None:
_, imgA_to_imgB_x, imgA_to_imgB_y = jaccard.jaccard_coef(
imgA, imgB)
else:
align_foo = getattr(THIS, align_foo_name)
imgA_to_imgB_x, imgA_to_imgB_y = align_foo(imgA, imgB, imgC)
imgA_aligned, imgB_aligned, aligned_to_B_x, aligned_to_B_y = utils.align(
imgA, imgB, imgA_to_imgB_x, imgA_to_imgB_y)
img_aligned = None
binary_trans = tran.get("value")
for tran in binary_trans:
name = tran.get("name")
if name is None:
continue
foo = getattr(THIS, name)
args = tran.get("args")
if args is None:
img_aligned = foo(imgA_aligned, imgB_aligned)
else:
img_aligned = foo(imgA_aligned, imgB_aligned, **args)
return img_aligned, int(imgA_to_imgB_x), int(
imgA_to_imgB_y), aligned_to_B_x, aligned_to_B_y
def subtract_diff(img, diff_to_ref_x, diff_to_ref_y, diff, ref, coords=False):
"""
:param img:
:param diff_to_ref_x:
:param diff_to_ref_y:
:param diff:
:param ref:
:return:
"""
if 0 == diff.sum():
if coords:
return img, 0, 0
else:
return img
_, img_to_ref_x, img_to_ref_y = jaccard.jaccard_coef(img, ref)
diff_to_img_x = diff_to_ref_x - img_to_ref_x
diff_to_img_y = diff_to_ref_y - img_to_ref_y
diff_aligned, img_aligned, aligned_to_img_x, aligned_to_img_y = utils.align(
diff, img, diff_to_img_x, diff_to_img_y)
result, result_to_aligned_x, result_to_aligned_y = utils.trim_binary_image(
utils.erase_noise_point(
np.logical_and(img_aligned, np.logical_not(diff_aligned)), 8),
coord=True)
if coords:
diff_to_result_x = (diff_to_img_x -
aligned_to_img_x) - result_to_aligned_x
diff_to_result_y = (diff_to_img_y -
aligned_to_img_y) - result_to_aligned_y
return result, diff_to_result_x, diff_to_result_y
else:
return result
def run_prob_anlg_tran(prob, anlg, tran):
"""
compute the result for a combination of a problem, an analogy and a transformation.
:param prob:
:param anlg:
:param tran:
:return:
"""
diff_to_u1_x = None
diff_to_u1_y = None
diff_to_u2_x = None
diff_to_u2_y = None
diff = None
b1_to_b2_x = None
b1_to_b2_y = None
if 3 == len(anlg.get("value")): # unary anlg and tran
u1 = prob.matrix[anlg.get("value")[0]]
u2 = prob.matrix[anlg.get("value")[1]]
print(prob.name, anlg.get("name"), tran.get("name"))
if "add_diff" == tran.get("name"):
score, diff_to_u1_x, diff_to_u1_y, diff_to_u2_x, diff_to_u2_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(u1, u2)
elif "subtract_diff" == tran.get("name"):
score, diff_to_u2_x, diff_to_u2_y, diff_to_u1_x, diff_to_u1_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(u2, u1)
else:
u1_t = transform.apply_unary_transformation(u1, tran)
score, _, _ = jaccard.jaccard_coef(u1_t, u2)
elif 5 == len(anlg.get("value")): # binary anlg and tran
b1 = prob.matrix[anlg.get("value")[0]]
b2 = prob.matrix[anlg.get("value")[1]]
b3 = prob.matrix[anlg.get("value")[2]]
b1_b2_t, b1_to_b2_x, b1_to_b2_y, _, _ = transform.apply_binary_transformation(
b1, b2, tran)
score, _, _ = jaccard.jaccard_coef(b1_b2_t, b3)
else:
raise Exception("Ryan!")
return {
"prob_name": prob.name,
"anlg_name": anlg.get("name"),
"tran_name": tran.get("name"),
"pat_score": score, # pat = prob + anlg + tran
"prob_ansr": prob.answer,
"prob_type": prob.type,
"anlg_type": anlg.get("type"),
"tran_type": tran.get("type"),
"diff_to_u1_x": diff_to_u1_x,
"diff_to_u1_y": diff_to_u1_y,
"diff_to_u2_x": diff_to_u2_x,
"diff_to_u2_y": diff_to_u2_y,
"diff": diff,
"b1_to_b2_x": b1_to_b2_x,
"b1_to_b2_y": b1_to_b2_y
}
def unite_align(A, B, C):
_, A_to_C_x, A_to_C_y = jaccard.jaccard_coef(A, C)
_, B_to_C_x, B_to_C_y = jaccard.jaccard_coef(B, C)
A_to_B_x = A_to_C_x - B_to_C_x
A_to_B_y = A_to_C_y - B_to_C_y
return A_to_B_x, A_to_B_y
def run_prob_anlg_tran_2x2(prob, anlg, tran):
u1 = prob.matrix[anlg.get("value")[0]]
u2 = prob.matrix[anlg.get("value")[1]]
diff_to_u1_x = None
diff_to_u1_y = None
diff_to_u2_x = None
diff_to_u2_y = None
diff = None
copies_to_u1_x = None
copies_to_u1_y = None
u1_coms_x = None
u1_coms_y = None
u2_coms_x = None
u2_coms_y = None
if "add_diff" == tran.get("name"):
score, diff_to_u1_x, diff_to_u1_y, diff_to_u2_x, diff_to_u2_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(u1, u2)
elif "subtract_diff" == tran.get("name"):
score, diff_to_u2_x, diff_to_u2_y, diff_to_u1_x, diff_to_u1_y, diff = \
asymmetric_jaccard.asymmetric_jaccard_coef(u2, u1)
elif "xor_diff" == tran.get("name"):
score, u1_to_u2_x, u1_to_u2_y = jaccard.jaccard_coef(u1, u2)
score = 1 - score
u1_aligned, u2_aligned, aligned_to_u2_x, aligned_to_u2_y = utils.align(
u1, u2, u1_to_u2_x, u1_to_u2_y)
diff = utils.erase_noise_point(np.logical_xor(u1_aligned, u2_aligned),
4)
diff_to_u2_x = int(aligned_to_u2_x)
diff_to_u2_y = int(aligned_to_u2_y)
diff_to_u1_x = int(diff_to_u2_x - u1_to_u2_x)
diff_to_u1_y = int(diff_to_u2_y - u1_to_u2_y)
elif "upscale_to" == tran.get("name"):
u1_upscaled = transform.upscale_to(u1, u2)
score, _, _ = jaccard.jaccard_coef(u2, u1_upscaled)
elif "duplicate" == tran.get("name"):
scores = []
u1_to_u2_xs = []
u1_to_u2_ys = []
current = u2.copy()
current_to_u2_x = 0
current_to_u2_y = 0
while current.sum():
score_tmp, diff_tmp_to_u1_x, diff_tmp_to_u1_y, diff_tmp_to_current_x, diff_tmp_to_current_y, _ = \
asymmetric_jaccard.asymmetric_jaccard_coef(u1, current)
if score_tmp < 0.6:
break
scores.append(score_tmp)
u1_to_current_x = (-diff_tmp_to_u1_x) - (-diff_tmp_to_current_x)
u1_to_current_y = (-diff_tmp_to_u1_y) - (-diff_tmp_to_current_y)
u1_to_u2_x = u1_to_current_x + current_to_u2_x
u1_to_u2_y = u1_to_current_y + current_to_u2_y
u1_to_u2_xs.append(u1_to_u2_x)
u1_to_u2_ys.append(u1_to_u2_y)
u1_aligned, current_aligned, aligned_to_current_x, aligned_to_current_y = utils.align(
u1, current, u1_to_current_x, u1_to_current_y)
current = utils.erase_noise_point(
np.logical_and(current_aligned, np.logical_not(u1_aligned)), 8)
current_to_u2_x = aligned_to_current_x + current_to_u2_x
current_to_u2_y = aligned_to_current_y + current_to_u2_y
if 1 >= len(scores):
score = 0
copies_to_u1_x = [0]
copies_to_u1_y = [0]
else:
score = min(scores)
copies_to_u1_x = (np.array(u1_to_u2_xs[1:]) -
u1_to_u2_xs[0]).tolist()
copies_to_u1_y = (np.array(u1_to_u2_ys[1:]) -
u1_to_u2_ys[0]).tolist()
elif "rearrange" == tran.get("name"):
score, u1_coms_x, u1_coms_y, u2_coms_x, u2_coms_y = transform.evaluate_rearrange(
u1, u2)
else:
u1_t = transform.apply_unary_transformation(u1, tran)
score, _, _ = jaccard.jaccard_coef(u1_t, u2)
if "mirror" == tran.get("name") or "mirror_rot_180" == tran.get("name"):
# if u1 or u2 is already symmetric, then we shouldn't use mirror tran.
u1_mirror_score, _, _ = jaccard.jaccard_coef(u1_t, u1)
u2_mirror = transform.apply_unary_transformation(u2, tran)
u2_mirror_score, _, _ = jaccard.jaccard_coef(u2_mirror, u2)
if max(u1_mirror_score, u2_mirror_score) > 0.9:
score = 0
prob_anlg_tran_d = assemble_prob_anlg_tran_d(prob,
anlg,
tran,
score,
diff_to_u1_x=diff_to_u1_x,
diff_to_u1_y=diff_to_u1_y,
diff_to_u2_x=diff_to_u2_x,
diff_to_u2_y=diff_to_u2_y,
diff=diff,
copies_to_u1_x=copies_to_u1_x,
copies_to_u1_y=copies_to_u1_y,
u1_coms_x=u1_coms_x,
u1_coms_y=u1_coms_y,
u2_coms_x=u2_coms_x,
u2_coms_y=u2_coms_y)
return prob_anlg_tran_d
def predict(prob, d):
anlg = analogy.get_anlg(d.get("anlg_name"))
tran = transform.get_tran(d.get("tran_name"))
if 3 == len(anlg.get("value")):
best_diff_to_u1_x = d.get("diff_to_u1_x")
best_diff_to_u1_y = d.get("diff_to_u1_y")
best_diff_to_u2_x = d.get("diff_to_u2_x")
best_diff_to_u2_y = d.get("diff_to_u2_y")
best_diff = d.get("diff")
u3 = prob.matrix[anlg.get("value")[2]]
u1 = prob.matrix[anlg.get("value")[0]]
if tran.get("name") == "add_diff":
prediction = transform.add_diff(u3, best_diff_to_u1_x,
best_diff_to_u1_y, best_diff, u1)
elif tran.get("name") == "subtract_diff":
prediction = transform.subtract_diff(u3, best_diff_to_u1_x,
best_diff_to_u1_y, best_diff,
u1)
else:
prediction = transform.apply_unary_transformation(u3, tran)
elif 5 == len(anlg.get("value")):
best_b1_to_b2_x = d.get("b1_to_b2_x")
best_b1_to_b2_y = d.get("b1_to_b2_y")
b1 = prob.matrix[anlg.get("value")[0]]
b2 = prob.matrix[anlg.get("value")[1]]
b4 = prob.matrix[anlg.get("value")[3]]
b5 = prob.matrix[anlg.get("value")[4]]
_, b4_to_b1_x, b4_to_b1_y = jaccard.jaccard_coef(b4, b1)
_, b5_to_b2_x, b5_to_b2_y = jaccard.jaccard_coef(b5, b2)
b4_to_b5_x = b4_to_b1_x - (b5_to_b2_x - best_b1_to_b2_x)
b4_to_b5_y = b4_to_b1_y - (b5_to_b2_y - best_b1_to_b2_y)
prediction, _, _, _, _ = transform.apply_binary_transformation(
b4, b5, tran, b4_to_b5_x, b4_to_b5_y)
else:
raise Exception("Ryan!")
pred_data = []
for ii, opt in enumerate(prob.options):
print(prob.name, anlg.get("name"), tran.get("name"), ii)
if tran.get("name") == "add_diff":
u1_to_u2_x = (-best_diff_to_u1_x) - (-best_diff_to_u2_x)
u1_to_u2_y = (-best_diff_to_u1_y) - (-best_diff_to_u2_y)
u3_score, diff = asymmetric_jaccard.asymmetric_jaccard_coef_pos_fixed(
u3, opt, u1_to_u2_x, u1_to_u2_y)
diff_score, _, _ = jaccard.jaccard_coef(diff, best_diff)
opt_score, _, _ = jaccard.jaccard_coef(opt, prediction)
score = (diff_score + opt_score + u3_score) / 3
elif tran.get("name") == "subtract_diff":
u2_to_u1_x = (-best_diff_to_u2_x) - (-best_diff_to_u1_x)
u2_to_u1_y = (-best_diff_to_u2_y) - (-best_diff_to_u1_y)
u3_score, diff = asymmetric_jaccard.asymmetric_jaccard_coef_pos_fixed(
opt, u3, u2_to_u1_x, u2_to_u1_y)
diff_score, _, _ = jaccard.jaccard_coef(diff, best_diff)
opt_score, _, _ = jaccard.jaccard_coef(opt, prediction)
score = (diff_score + opt_score + u3_score) / 3
else:
score, _, _ = jaccard.jaccard_coef(opt, prediction)
pred_data.append({
**d, "optn": ii + 1,
"pato_score": score,
"pred": prediction
})
return pred_data
