def test_conjunction_fuzzy_with_virtual_evaluation(self):
"""Test for correct vardecl parameter initialization in BackwardChainer
vardecl = VariableList() would cause empty set as backward chaining result
vardecl = UNDEFINED should produce two results: (Item0, large), (Item1, small)
"""
self.init()
scheme_eval(self.atomspace, '(load-from-path "fuzzy-conjunction-introduction-config.scm")')
rbs = ConceptNode("conjunction-rule-base")
item0 = ConceptNode("Item0")
item1 = ConceptNode("Item1")
size = ConceptNode("Size")
small = ConceptNode("small")
large = ConceptNode("large")
InheritanceLink(item0, ConceptNode("Items")).tv = TruthValue(0.9, 0.9)
InheritanceLink(item1, ConceptNode("Items")).tv = TruthValue(0.9, 0.9)
InheritanceLink(small, size).tv = TruthValue(1.0, 1.0)
InheritanceLink(large, size).tv = TruthValue(1.0, 1.0)
P = GroundedPredicateNode("py:run_predicate")
X = VariableNode("$X")
Y = VariableNode("$Y")
P_A = EvaluationLink(P, ListLink(X, Y))
target = AndLink(InheritanceLink(Y, size), InheritanceLink(X, ConceptNode("Items")), P_A)
bc = BackwardChainer(self.atomspace, rbs, target)
bc.do_chain()
results = bc.get_results()
self.assertTrue(len(results.get_out()) == 2)
del bc
def test_modus_ponens(self):
rule_base = ConceptNode('PLN')
set_ttv(ConceptNode("apple"), TTruthValue((0.8, 0.9)))
inh = InheritanceLink(ConceptNode("apple"), ConceptNode("fruit"))
set_ttv(inh, TTruthValue(0.8, 0.4))
bc = BackwardChainer(self.atomspace, rule_base, ConceptNode("fruit"))
bc.do_chain()
result = get_ttv(bc.get_results().out[0])
self.assertTrue(abs(0.68 - float(result.mean)) < 0.0001)
def test_modus_ponens(self):
rule_base = initialize_pln()
set_ttv(ConceptNode("apple"), TTruthValue((0.8, 0.9)))
inh = InheritanceModule(ConceptNode("apple"),
ConceptNode("fruit"),
tv=torch.tensor((0.8, 0.4)))
bc = BackwardChainer(self.atomspace, rule_base, ConceptNode("fruit"))
bc.do_chain()
result = get_ttv(bc.get_results().out[0])
self.assertTrue((0.68 - float(result.mean)) < 0.00000000000001)
def run_message_passing_ure():
res = execute_atom(atomspace, directed_message_edge_creation_rule)
res = execute_atom(atomspace, create_initial_messages_rule)
fc_message_sending_rule_name = DefinedSchemaNode("fc-message-sending-rule")
DefineLink(fc_message_sending_rule_name, create_messages_rule)
fc_message_sending_rbs = ConceptNode("fc-message-sending-rule")
InheritanceLink(fc_message_sending_rbs, ConceptNode("URE"))
MemberLink(fc_message_sending_rule_name, fc_message_sending_rbs)
# Set URE maximum-iterations
from opencog.scheme_wrapper import scheme_eval
execute_code = \
'''
(use-modules (opencog rule-engine))
(ure-set-num-parameter (ConceptNode "fc-message-sending-rbs") "URE:maximum-iterations" 30)
'''
scheme_eval(atomspace, execute_code)
# chainer = ForwardChainer(atomspace,
# ConceptNode("fc-message-sending-rule"),
# SetLink())
# log.set_level('FINE')
# chainer = ForwardChainer(atomspace,
# ConceptNode("fc-message-sending-rule"),
# get_message(VariableNode("$V1"), VariableNode("$V2")),
# VariableList(
# TypedVariableLink(VariableNode("$V1"), TypeNode("ConceptNode")),
# TypedVariableLink(VariableNode("$V2"), TypeNode("ConceptNode")))
# )
# chainer = BackwardChainer(atomspace,
# ConceptNode("fc-message-sending-rule"),
# get_message(VariableNode("$V1"), VariableNode("$V2")))
chainer = BackwardChainer(
atomspace, ConceptNode("fc-message-sending-rule"),
get_message(VariableNode("$V1"), VariableNode("$V2")),
VariableList(
TypedVariableLink(VariableNode("$V1"), TypeNode("ConceptNode")),
TypedVariableLink(VariableNode("$V2"), TypeNode("ConceptNode"))))
chainer.do_chain()
results = chainer.get_results()
log.set_level('INFO')
res = execute_atom(atomspace, create_node_value_rule)
def test_contraposition(self):
rule_base = ConceptNode('PLN')
A = PredicateNode('A')
set_ttv(A, (1.0, 1.0))
B = PredicateNode('B')
set_ttv(B, (1.0, 1.0))
set_ttv(ImplicationLink(A, B), (1.0, 1.0))
NBNA = ImplicationLink(NotLink(B), NotLink(A))
bc = BackwardChainer(self.atomspace, rule_base, NBNA)
bc.do_chain()
result = bc.get_results().out[0]
self.assertTrue(0 < get_ttv(result).confidence,
'fails due to https://github.com/opencog/opencog/issues/3465')
def test_fuzzy_conjunction(self):
rule_base = ConceptNode('PLN')
apple = ConceptNode('apple')
inh_green = InheritanceLink(PredicateNode("green"), ConceptNode("color"))
set_ttv(inh_green, torch.tensor([0.96, .9]))
ev_green = EvaluationLink(PredicateNode('green'), apple)
set_ttv(ev_green, TTruthValue(0.85, 0.95))
conj = AndLink(ev_green, inh_green)
bc = BackwardChainer(self.atomspace, rule_base, conj)
bc.do_chain()
result = get_ttv(bc.get_results().out[0])
self.assertTrue(abs(result.mean - 0.85) < 0.0001)
self.assertTrue(abs(result.confidence - 0.9) < 0.0001)
def test_bc_deduction(self):
"""port of crisp.scm from examples/rule-engine/simple"""
print("Enter test_bc_deduction")
self.init()
print("test_bc_deduction: pre scheme eval")
scheme_eval(self.atomspace, '(use-modules (opencog))')
scheme_eval(self.atomspace, '(use-modules (opencog exec))')
scheme_eval(self.atomspace, '(use-modules (opencog rule-engine))')
print("test_bc_deduction: pre scheme load")
scheme_eval(self.atomspace,
'(load-from-path "bc-deduction-config.scm")')
print("test_bc_deduction: post scheme load")
A = ConceptNode("A", TruthValue(1, 1))
B = ConceptNode("B")
C = ConceptNode("C")
AB = InheritanceLink(A, B)
AB.tv = TruthValue(1, 1)
BC = InheritanceLink(B, C)
BC.tv = TruthValue(1, 1)
crisprbs = ConceptNode("crisp-rule-base")
# InheritanceLink(crisprbs, ConceptNode("URE"))
print("test_bc_deduction: pre backchain ctor")
chainer = BackwardChainer(
self.atomspace, ConceptNode("URE"),
InheritanceLink(VariableNode("$who"), C),
TypedVariableLink(VariableNode("$who"), TypeNode("ConceptNode")))
scheme_eval(self.atomspace, '(gc)')
print("test_bc_deduction: post backchain ctor")
chainer.do_chain()
print("test_bc_deduction: post chaining")
scheme_eval(self.atomspace, '(gc)')
results = chainer.get_results()
print("test_bc_deduction: post results")
scheme_eval(self.atomspace, '(gc)')
resultAC = None
for result in results.get_out():
if result.get_out()[0].name == "A":
resultAC = result
break
self.assertTrue(resultAC is not None)
self.assertTrue(resultAC.tv == AB.tv)
self.assertEquals("A", resultAC.get_out()[0].name)
self.assertEquals("C", resultAC.get_out()[1].name)
del chainer
def main():
build_modus_ponens()
# train implication or just weigths of modus_ponens_formula
train_implication = False
if train_implication:
print("train implication and modus_ponens_formula' weights")
else:
print("train only modus_ponens_formula' weights")
optimizer = optim.SGD(params(train_implication), lr=1e-1)
initial_w = w.clone()
print('initial ' + res_string.format(*initial_w))
print("inital implication links")
for color in colors:
for fruit in fruits:
print(ImplicationLink(PredicateNode(fruit), PredicateNode(color)))
for i in range(300):
fruit_id = np.random.randint(len(fruits))
color_id = np.random.choice(len(colors), p=Pcolorfruit[fruit_id])
fruit = fruits[fruit_id]
color = colors[color_id]
x = fruit + "-" + str(i)
set_ttv(EvaluationLink(PredicateNode(fruit), ConceptNode(x)),
TTruthValue(1.0, 1.0))
optimizer.zero_grad()
loss = torch.zeros(1)
for c in colors:
bc = BackwardChainer(
atomspace, rule_base,
EvaluationLink(PredicateNode(c), ConceptNode(x)))
bc.do_chain()
evlink = bc.get_results().out[0]
p = get_ttv(evlink)
# print(evlink)
if color == c:
loss = loss - torch.log(p[0])
else:
loss = loss - torch.log(1 - p[0])
loss.backward()
optimizer.step()
print("implication links")
for color in colors:
for fruit in fruits:
print(ImplicationLink(PredicateNode(fruit), PredicateNode(color)))
print("after training")
print(res_string.format(w[0], w[1], w[2], w[2], w[3]))
def test_bc_deduction(self):
"""port of crisp.scm from examples/ure/simple"""
print ("Enter test_bc_deduction")
self.init()
print ("test_bc_deduction: pre scheme eval")
scheme_eval(self.atomspace, '(use-modules (opencog))')
scheme_eval(self.atomspace, '(use-modules (opencog exec))')
scheme_eval(self.atomspace, '(use-modules (opencog ure))')
print ("test_bc_deduction: pre scheme load")
scheme_eval(self.atomspace, '(load-from-path "bc-deduction-config.scm")')
print ("test_bc_deduction: post scheme load")
A = ConceptNode("A", TruthValue(1, 1))
B = ConceptNode("B")
C = ConceptNode("C")
AB = InheritanceLink(A, B)
AB.tv = TruthValue(1, 1)
BC = InheritanceLink(B, C)
BC.tv = TruthValue(1, 1)
crisprbs = ConceptNode("crisp-rule-base")
# InheritanceLink(crisprbs, ConceptNode("URE"))
print ("test_bc_deduction: pre backchain ctor")
chainer = BackwardChainer(self.atomspace,
ConceptNode("URE"),
InheritanceLink(VariableNode("$who"), C),
TypedVariableLink(VariableNode("$who"), TypeNode("ConceptNode")))
scheme_eval(self.atomspace, '(gc)')
print ("test_bc_deduction: post backchain ctor")
chainer.do_chain()
print ("test_bc_deduction: post chaining")
scheme_eval(self.atomspace, '(gc)')
results = chainer.get_results()
print ("test_bc_deduction: post results")
scheme_eval(self.atomspace, '(gc)')
resultAC = None
for result in results.get_out():
if result.get_out()[0].name == "A":
resultAC = result
break
self.assertTrue(resultAC is not None)
self.assertTrue(resultAC.tv == AB.tv)
self.assertEquals("A", resultAC.get_out()[0].name)
self.assertEquals("C", resultAC.get_out()[1].name)
del chainer
def test_cons_disj_elimination(self):
rule_base = ConceptNode('PLN')
A = PredicateNode('A')
set_ttv(A, (1.0, 1.0))
B = PredicateNode('B')
set_ttv(B, (1.0, 1.0))
C = PredicateNode('C')
set_ttv(C, (1.0, 1.0))
set_ttv(ImplicationLink(A, C), (0.55, 0.55))
set_ttv(ImplicationLink(A, OrLink(B, C)), (1.0, 1.0))
impl = ImplicationLink(A, B)
bc = BackwardChainer(self.atomspace, rule_base, impl)
bc.do_chain()
result = get_ttv(bc.get_results().out[0])
self.assertTrue(result.mean == 1.0)
alpha = 0.9
self.assertTrue(result.confidence == alpha * 0.55)
def main():
generate_modus_ponens()
optimizer = optim.SGD(params(), lr=1e-2)
for i in range(100):
fruit_id = np.random.randint(len(fruits))
color_id = np.random.choice(len(colors),
p=P_color_given_fruit[fruit_id])
fruit = fruits[fruit_id]
color = colors[color_id]
x = fruit + "-" + str(i)
# a particular fruit, color observation
EvaluationLink(PredicateNode(fruit),
ConceptNode(x)).tv = TTruthValue(1.0, 1.0)
optimizer.zero_grad()
loss = torch.zeros(1)
for c in colors:
# compute P(fruit|color)
bc = BackwardChainer(
atomspace, rule_base,
EvaluationLink(PredicateNode(c), ConceptNode(x)))
bc.do_chain()
evlink = bc.get_results().out[0]
p_fruit_given_color = evlink.tv
print(evlink)
if color == c:
loss = loss - torch.log(p_fruit_given_color.mean)
else:
loss = loss - torch.log(1 - p_fruit_given_color.mean)
print('loss: ' + str(loss))
loss.backward()
optimizer.step()
print("results after train:")
for color in colors:
for fruit in fruits:
print(ImplicationLink(PredicateNode(fruit), PredicateNode(color)))
def test_rule_engine(self):
rule_base = initialize_pln()
apple = ConceptNode('apple')
colors = torch.rand(3, 4, 4)
colors[GREEN] = 0.8
colors = colors
inp = InputModule(apple, colors)
# red <- color
# green <- color
green = GreenPredicate(ConceptNode('green'))
inh_red = InheritanceLink(ConceptNode("red"), ConceptNode("color"))
inh_red = InheritanceModule(inh_red, torch.tensor([0.9, 0.95]))
inh_green = InheritanceModule(ConceptNode("green"),
ConceptNode("color"),
tv=torch.tensor([0.6, .9]))
# And(Evaluation(GreenPredicate, apple), Inheritance(green, color))
conj = AndLink(green.evaluate(inp.execute()), inh_green.execute())
bc = BackwardChainer(self.atomspace, rule_base, conj)
bc.do_chain()
result = get_ttv(bc.get_results().out[0])
self.assertEqual(min(colors[GREEN].mean(), inh_green.tv.mean),
result.mean)
self.assertEqual(inh_green.tv.confidence, result.confidence)
# Initialize AtomSpace
atomspace = AtomSpace()
initialize_opencog(atomspace)
# Import URE Deduction Rules
from sample_ure_deduction import *
# Knowledge Base
A = ConceptNode("A")
B = ConceptNode("B")
C = ConceptNode("C")
AB = InheritanceLink(A, B)
BC = InheritanceLink(B, C)
A.tv = TruthValue(1, 1)
AB.tv = TruthValue(0.8, 0.9)
BC.tv = TruthValue(0.85, 0.95)
# Run Forward Chainer
chainer = BackwardChainer(
atomspace, deduction_rbs, InheritanceLink(VariableNode("$X"), C),
TypedVariableLink(VariableNode("$X"), TypeNode("ConceptNode")))
chainer.do_chain()
results = chainer.get_results()
print(results)
