def benchmark_knowledge_base_size(target,
bases,
min_n=1,
max_n=1,
step=1,
reps=1):
sigma = 0.5
neuro_analogy = NeuralAnalogy(sigma, wm_c, max_ar, sem_dim)
neuro_analogy.make(target, bases)
results = []
for i in range(min_n, max_n + 1, step):
KB = []
while len(KB) < i:
b_rnd = np.random.randint(0, len(bases))
KB.append(bases[b_rnd])
if len(KB) > 0:
dt = 0
for r in range(reps):
time1 = time.time()
neuro_analogy.make(target, KB)
dt += time.time() - time1
results.append((len(KB), dt / float(reps)))
return results
bill_b1 = Atom("Bill")
apple_b1 = Atom("apple")
core_b1 = Atom("core")
loves_b1 = Predicate("loves", 2, [john_b1], [mary_b1])
has_b1 = Predicate("has", 2, [apple_b1], [core_b1])
knows1_b1 = Predicate("knows", 2, [bill_b1], [loves_b1])
knows2_b1 = Predicate("knows", 2, [john_b1], [has_b1])
#Vector encoder using Glove 50d word word embeddings
encoder = Glove50Encoder(r_slots_n, max_ar)
#encoder = VectorEncoder(r_slots_n, max_ar, sem_dim)
#encode target
#target_v is a vector represenbtation, target_ps contains the corresponding predicatres
target_v, target_ps = encoder.encode_predicates([loves_t, knows1_t, knows2_t])
#encode base
base_v, base_p = encoder.encode_predicates([loves_b1, knows1_b1, knows2_b1])
#create neuual analogical machine
neuro_analogy = NeuralAnalogy(sigma, r_slots_n, max_ar, sem_dim)
#run mapping
(max_sim, _, mapping) = neuro_analogy.make(target_v, base_v)
#Print the overal simialriyt of the target and the basae
print("Similarity: {}".format(max_sim))
#Print mappings
for i in range(r_slots_n):
target_p = target_ps[np.argmax(mapping[:, i])]
print("{}<->{}".format(target_p, base_p[i]))
def benchmark():
wm_c = 8
sem_dim = 50
max_ar = 2
o1_1 = Atom("o1")
o2_1 = Atom("o2")
o1_2 = Atom("o1")
o2_2 = Atom("o2")
o1_3 = Atom("o1")
o2_3 = Atom("o2")
r1_1 = Predicate("r1111", 2, [o1_1], [o2_1])
r2_1 = Predicate("r2222", 2, [o2_1], [o1_1])
r1_2 = Predicate("r1000", 2, [o2_2], [o1_2])
r2_2 = Predicate("r2sss", 2, [o1_2], [o2_2])
r1_3 = Predicate("r1eeee", 2, [o2_3], [o1_3])
r2_3 = Predicate("r2rrr", 2, [o1_3], [o2_3])
target = Predicate("cause0", 2, [r1_1], [r2_1])
base1 = Predicate("cause1", 2, [r1_2], [r2_2])
base2 = Predicate("cause2", 2, [r2_3], [r1_3])
encoder = Glove50Encoder(wm_c, max_ar)
#encoder = VectorEncoder(wm_c, max_ar, sem_dim)
base_predicates = [
[base1],
[base2],
]
bases = {}
base_ps = {}
for i in range(len(base_predicates)):
vec_repr, ps = encoder.encode_predicates(base_predicates[i])
bases[i] = vec_repr
base_ps[i] = ps
target, target_ps = encoder.encode_predicates([target])
#crossed = []
sigma_i_step = 10
for sigma_i in range(50, 51, sigma_i_step):
#crossed.append(0.0)
analogy = NeuralAnalogy(sigma_i / 100.0, wm_c, max_ar, sem_dim, False)
for base_i in bases:
(max_sim, _, mapping) = analogy.make(target, bases[base_i])
#print_v "None"
# print([str(p) for p in target_ps])(mapping)
# print_v(target)
# print_v(bases[base_i])
# print(mapping)
# john_mapping =
for i in range(len(base_ps[base_i])):
base_p = base_ps[base_i][i]
target_p = target_ps[np.argmax(mapping[:, i])]
print("{}<->{}".format(target_p, base_p))
print("sigma: {:.3}, base: {}, sim :{:.5}".format(sigma_i / 100.0, base_i, max_sim))
for t in traces["john"]:
traces["john"][t].append((None, None))
traces["mary"][t].append((None, None))
base_bars[base_i] = {
"john": {
"corr": [],
"cross": [],
"rel": [],
"none": []
}
}
for sigma_i in range(0, 101, 10):
neuro_analogy = NeuralAnalogy(sigma_i / 100.0, wm_c, max_ar, sem_dim)
(max_sim, _, mapping) = neuro_analogy.make(target_v, bases[base_i][0])
t = [(bases[base_i][1][i].get_arguments()[0],
bases[base_i][1][i].get_arguments()[1])
for i in range(len(bases[base_i][1]))
if (type(bases[base_i][1][i]) is Predicate) and (
bases[base_i][1][i].get_arity() == 2)][0]
args = [t[0][0], t[1][0]]
for i in range(len(bases[base_i][1])):
base_p = bases[base_i][1][i]
target_p = target_ps[np.argmax(mapping[:, i])]
#print("{}<->{}".format(target_p, base_p))
if target_p <> None:
if not (args.csv):
print("{:>5}\t{}".format("N", "Time (sec)"))
for i in range(len(results)):
if not (args.csv):
print("{:>5}\t{:.4}".format(results[i][0], results[i][1]))
else:
print("{},{:.8}".format(results[i][0], results[i][1]))
exit(0)
print("---------------Analogy-----------")
print("\n")
for sigma_i in range(50, 51, sigma_i_step):
neuro_analogy = NeuralAnalogy(sigma_i / 100.0, wm_c, max_ar, sem_dim)
# print("---------------Mapping-----------")
# for base_i in bases:
# (max_sim, _, mapping) = analogy.make(target_v, bases[base_i][0])
# for i in range(len(bases[base_i][1])):
# base_p = bases[base_i][1][i]
# target_p = target_ps[np.argmax(mapping[:, i])]
# print("{}<->{}".format(target_p, base_p))
#
#
# print("sigma: {:.3}, base: {}, sim :{:.5}".format(sigma_i / 100.0, base_i, max_sim))
# print("\n")
time1 = time.time()
(max_sim, best_base_no, mapping) = neuro_analogy.make(target_v, bases_v)
time2 = time.time()