def test_neg():
# setup
net = Network()
c0 = Has('$x', 'on', '$y')
c1 = Has('$y', 'left-of', '$z')
c2 = Neg('$z', 'color', 'red')
p0 = net.add_production(Rule(c0, c1, c2))
# end
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red'),
# WME('B4', 'color', 'blue'),
]
for wme in wmes:
net.add_wme(wme)
assert p0.items[0].wmes == [
WME('B1', 'on', 'B3'),
WME('B3', 'left-of', 'B4'), None
]
def test_ncc():
net = Network()
c0 = Has('$x', 'on', '$y')
c1 = Has('$y', 'left-of', '$z')
c2 = Neg('$z', 'color', 'red') # YKY: allowed to have Neg inside Ncc
c3 = Has('$z', 'on', '$w')
p0 = net.add_production(Rule(c0, c1, Ncc(c2, c3)))
save_Rete_graph(net, 'rete-0')
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
]
for wme in wmes:
net.add_wme(wme)
print("# of results [2] = ", len(p0.items))
# assert len(p0.items) == 2
net.add_wme(WME('B3', 'color', 'red'))
print("# of results [1] = ", len(p0.items))
def init_network():
net = Network()
c0 = Has('$x', 'on', '$y')
c1 = Has('$y', 'left-of', '$z')
c2 = Has('$z', 'color', 'red')
net.add_production(Rule(c0, c1, c2))
return net
def test__integration(self):
for i, (rule, wmes, exp_len, var, exp_val) in enumerate([
(Rule(Has('spu:1', 'price', '$x'), Filter('$x>100'), Filter('$x<200')),
[WME('spu:1', 'price', '100'), WME('spu:1', 'price', '150'), WME('spu:1', 'price', '300')],
1,
'$x',
'150'),
(Rule(Has('spu:1', 'price', '$x'), Filter('$x>200 and $x<400')),
[WME('spu:1', 'price', '100'), WME('spu:1', 'price', '150'), WME('spu:1', 'price', '300')],
1,
'$x',
'300'),
(Rule(Has('spu:1', 'price', '$x'), Filter('$x>300')),
[WME('spu:1', 'price', '100'), WME('spu:1', 'price', '150'), WME('spu:1', 'price', '300')],
0,
None,
None),
]):
with self.subTest(i=i, exp_len=exp_len, var=var, exp_val=exp_val):
network = Network()
production = network.add_production(rule)
for wme in wmes:
network.add_wme(wme)
assert_that(production.memory, 'filter').is_length(exp_len)
if production.memory:
token = production.memory[0]
assert_that(token.get_binding(var), 'filter').is_equal_to(exp_val)
def test_recurring_vars_should_not_match():
net = Network()
c0 = Has('foo', '$x', '$x')
p0 = net.add_production(Rule(c0))
net.add_wme(WME('foo', 'bar', 'baz'))
assert len(p0.items) == 0
def test_all_constants_the_same_should_not_match():
net = Network()
c0 = Has('foo', 'foo', 'foo')
p0 = net.add_production(Rule(c0))
net.add_wme(WME('bar', 'foo', 'foo'))
assert len(p0.items) == 0
def test_multiple_conditions_should_not_match():
net = Network()
c0 = Has('foo', '$x', '$y')
c1 = Has('foo', '$x', '$x')
c2 = Has('$x', '$y', 'baz')
p0 = net.add_production(Rule(c0, c1, c2))
net.add_wme(WME('foo', 'bar', 'baz'))
assert len(p0.items) == 0
def test_multiple_conditions_all_variables_should_match_one():
net = Network()
c0 = Has('foo', 'foo', 'foo')
c1 = Has('$x', '$x', '$x')
c2 = Has('$x', 'foo', 'foo')
c3 = Has('foo', '$x', 'foo')
c4 = Has('$x', 'foo', '$x')
p0 = net.add_production(Rule(c0, c1, c2, c3, c4))
net.add_wme(WME('foo', 'foo', 'foo'))
assert len(p0.items) == 1
def test__case_1(self):
for i, (rule, wmes, exp) in enumerate([(Rule(
Has('$x', 'on', '$y'),
Has('$y', 'left-of', '$z'),
Has('$z', 'color', 'red'),
), [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red')
], [])]):
with self.subTest(i=i, rule=rule, wmes=wmes, exp=exp):
network = Network()
production = network.add_production(rule)
am0 = network.build_or_share_alpha_memory(rule[0])
am1 = network.build_or_share_alpha_memory(rule[1])
am2 = network.build_or_share_alpha_memory(rule[2])
dummy_join = am0.children[0]
join_on_value_y = am1.children[0]
join_on_value_z = am2.children[0]
match_c0 = dummy_join.children[0]
match_c0c1 = join_on_value_y.children[0]
match_c0c1c2 = join_on_value_z.children[0]
for wme in wmes:
network.add_wme(wme)
assert am0.memory == [wmes[0], wmes[1], wmes[3], wmes[7]]
assert am1.memory == [wmes[4], wmes[6]]
assert am2.memory == [wmes[2], wmes[8]]
assert len(match_c0.memory) == 4
assert len(match_c0c1.memory) == 2
assert len(match_c0c1c2.memory) == 1
t0 = Token(Token(None, None), wmes[0])
t1 = Token(t0, wmes[4])
t2 = Token(t1, wmes[8])
assert match_c0c1c2.memory[0] == t2
network.remove_wme(wmes[0])
assert am0.memory == [wmes[1], wmes[3], wmes[7]]
assert len(match_c0.memory) == 3
assert len(match_c0c1.memory) == 1
assert len(match_c0c1c2.memory) == 0
def test_network_case1():
# setup
net = Network()
c0 = Has('$x', 'on', '$y')
c1 = Has('$y', 'left-of', '$z')
c2 = Has('$z', 'color', 'red')
net.add_production(Rule(c0, c1, c2))
# end
am0 = net.build_or_share_alpha_memory(c0)
am1 = net.build_or_share_alpha_memory(c1)
am2 = net.build_or_share_alpha_memory(c2)
dummy_join = am0.successors[0]
join_on_value_y = am1.successors[0]
join_on_value_z = am2.successors[0]
match_c0 = dummy_join.children[0]
match_c0c1 = join_on_value_y.children[0]
match_c0c1c2 = join_on_value_z.children[0]
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red')
]
for wme in wmes:
net.add_wme(wme)
assert am0.items == [wmes[0], wmes[1], wmes[3], wmes[7]]
assert am1.items == [wmes[4], wmes[6]]
assert am2.items == [wmes[2], wmes[8]]
assert len(match_c0.items) == 4
assert len(match_c0c1.items) == 2
assert len(match_c0c1c2.items) == 1
t0 = Token(Token(None, None), wmes[0])
t1 = Token(t0, wmes[4])
t2 = Token(t1, wmes[8])
assert match_c0c1c2.items[0] == t2
net.remove_wme(wmes[0])
assert am0.items == [wmes[1], wmes[3], wmes[7]]
assert len(match_c0.items) == 3
assert len(match_c0c1.items) == 1
assert len(match_c0c1c2.items) == 0
def test__integration(self):
for i, (rule, wmes, exp_len, var, exp_val) in enumerate([
(Rule(Has('spu:1', 'sales', '$x'), Bind('len(set($x) & set(range(1, 100)))', '$num'), Filter('$num > 0')),[WME('spu:1', 'sales', 'range(50, 110)')], 1, '$num', 50),
(Rule(Has('spu:1', 'sales', '$x'), Bind('len(set($x) & set(range(100, 200)))', '$num'), Filter('$num > 0')),[WME('spu:1', 'sales', 'range(50, 110)')], 1, '$num', 10),
(Rule(Has('spu:1', 'sales', '$x'), Bind('len(set($x) & set(range(300, 400)))', '$num'), Filter('$num > 0')),[WME('spu:1', 'sales', 'range(50, 110)')], 0, None, None),
]):
with self.subTest(i=i, exp_len=exp_len, var=var, exp_val=exp_val):
network = Network()
production = network.add_production(rule)
for wme in wmes:
network.add_wme(wme)
assert_that(production.memory, 'filter').is_length(exp_len)
if production.memory:
token = production.memory[0]
assert_that(token.get_binding(var), 'filter').is_equal_to(exp_val)
def test_network_case0():
net = Network()
c0 = Has('x', 'id', '1')
c1 = Has('x', 'kind', '8')
p0 = net.add_production(Rule(c0, c1))
w0 = WME('x', 'id', '1')
w1 = WME('x', 'kind', '8')
net.add_wme(w0)
assert not p0.items
net.remove_wme(w0)
net.add_wme(w1)
assert not p0.items
net.add_wme(w0)
net.add_wme(w1)
assert p0.items
def test__case_0(self):
for i, (rule, wmes, exp) in enumerate([
(Rule(Has('x', 'id', '1'), Has('x', 'kind',
'8')), [WME('x', 'id', '1')], 0),
(Rule(Has('x', 'id', '1'), Has('x', 'kind',
'8')), [WME('x', 'kind', '8')], 0),
(Rule(Has('x', 'id', '1'),
Has('x', 'kind',
'8')), [WME('x', 'id', '1'),
WME('x', 'kind', '8')], 1),
]):
with self.subTest(i=i, rule=rule, wmes=wmes, exp=exp):
network = Network()
production = network.add_production(rule)
for wme in wmes:
network.add_wme(wme)
result = len(production.memory)
assert_that(result, 'case 0').is_equal_to(exp)
def test_dup():
# setup
net = Network()
c0 = Has('$x', 'self', '$y')
c1 = Has('$x', 'color', 'red')
c2 = Has('$y', 'color', 'red')
net.add_production(Rule(c0, c1, c2))
wmes = [
WME('B1', 'self', 'B1'),
WME('B1', 'color', 'red'),
]
for wme in wmes:
net.add_wme(wme)
# end
am = net.build_or_share_alpha_memory(c2)
join_on_value_y = am.successors[1]
match_for_all = join_on_value_y.children[0]
assert len(match_for_all.items) == 1
def test_bind():
net = Network()
c0 = Has('spu:1', 'sales', '$x')
b0 = Bind('len(set($x) & set(range(1, 100)))', '$num')
f0 = Filter('$num > 0')
p0 = net.add_production(Rule(c0, b0, f0))
b1 = Bind('len(set($x) & set(range(100, 200)))', '$num')
p1 = net.add_production(Rule(c0, b1, f0))
b2 = Bind('len(set($x) & set(range(300, 400)))', '$num')
p2 = net.add_production(Rule(c0, b2, f0))
net.add_wme(WME('spu:1', 'sales', 'range(50, 110)'))
assert len(p0.items) == 1
assert len(p1.items) == 1
assert len(p2.items) == 0
t0 = p0.items[0]
t1 = p1.items[0]
assert t0.get_binding('$num') == 50
assert t1.get_binding('$num') == 10
def test_ncc():
net = Network()
c0 = Has('$x', 'on', '$y')
c1 = Has('$y', 'left-of', '$z')
c2 = Has('$z', 'color', 'red')
c3 = Has('$z', 'on', '$w')
p0 = net.add_production(Rule(c0, c1, Ncc(c2, c3)))
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
]
for wme in wmes:
net.add_wme(wme)
assert len(p0.items) == 2
net.add_wme(WME('B3', 'color', 'red'))
assert len(p0.items) == 1
def test_multi_productions():
net = Network()
c0 = Has('$x', 'on', '$y')
c1 = Has('$y', 'left-of', '$z')
c2 = Has('$z', 'color', 'red')
c3 = Has('$z', 'on', 'table')
c4 = Has('$z', 'left-of', 'B4')
p0 = net.add_production(Rule(c0, c1, c2))
p1 = net.add_production(Rule(c0, c1, c3, c4))
wmes = [
WME('B1', 'on', 'B2'),
WME('B1', 'on', 'B3'),
WME('B1', 'color', 'red'),
WME('B2', 'on', 'table'),
WME('B2', 'left-of', 'B3'),
WME('B2', 'color', 'blue'),
WME('B3', 'left-of', 'B4'),
WME('B3', 'on', 'table'),
WME('B3', 'color', 'red'),
]
for wme in wmes:
net.add_wme(wme)
# add product on the fly
p2 = net.add_production(Rule(c0, c1, c3, c2))
assert len(p0.items) == 1
assert len(p1.items) == 1
assert len(p2.items) == 1
assert p0.items[0].wmes == [wmes[0], wmes[4], wmes[8]]
assert p1.items[0].wmes == [wmes[0], wmes[4], wmes[7], wmes[6]]
assert p2.items[0].wmes == [wmes[0], wmes[4], wmes[7], wmes[8]]
net.remove_production(p2)
assert len(p2.items) == 0
def test_filter_compare():
net = Network()
c0 = Has('spu:1', 'price', '$x')
f0 = Filter('$x>100')
f1 = Filter('$x<200')
f2 = Filter('$x>200 and $x<400')
f3 = Filter('$x>300')
p0 = net.add_production(Rule(c0, f0, f1))
p1 = net.add_production(Rule(c0, f2))
p2 = net.add_production(Rule(c0, f3))
net.add_wme(WME('spu:1', 'price', '100'))
net.add_wme(WME('spu:1', 'price', '150'))
net.add_wme(WME('spu:1', 'price', '300'))
assert len(p0.items) == 1
token = p0.items.pop()
assert token.get_binding('$x') == '150'
assert len(p1.items) == 1
token = p1.items.pop()
assert token.get_binding('$x') == '300'
assert not p2.items
def test_black_white():
net = Network()
c1 = Has('$item', 'cat', '$cid')
c2 = Has('$item', 'shop', '$sid')
white = Ncc(
Has('$item', 'cat', '100'),
Neg('$item', 'cat', '101'),
Neg('$item', 'cat', '102'),
)
n1 = Neg('$item', 'shop', '1')
n2 = Neg('$item', 'shop', '2')
n3 = Neg('$item', 'shop', '3')
p0 = net.add_production(Rule(c1, c2, white, n1, n2, n3))
wmes = [
WME('item:1', 'cat', '101'),
WME('item:1', 'shop', '4'),
WME('item:2', 'cat', '100'),
WME('item:2', 'shop', '1'),
]
for wme in wmes:
net.add_wme(wme)
assert len(p0.items) == 1
assert p0.items[0].get_binding('$item') == 'item:1'
# **** This is a second (improved) representation of the logic of Tic Tac Toe.
# We seek to find a representation that is most "natural" and close to human thinking.
# TO-DO:
# * need ability to make logic assumptions (how?)
# * need fuzzy or probabilistic truth values (to generate stochastic actions)
import sys
import os
from rete.common import DEBUG, Has, Rule, WME, Neg, Ncc, Token
from rete.network import Network
print("\n\x1b[32m——`—,—{\x1b[31;1m@\x1b[0m\n") # Genifer logo ——`—,—{@
net = Network()
p = [] # list of p-Nodes
# **** General strategy ****
# - if can win, play it
# - about to lose, play it
# - if center not occupied, play it
# - if able to 'double-fork', play it
# - play randomly
# row 0 win:
q = net.add_production(
Rule(
Has('□', '$x'),
Has('X', '$y'),
Has('X', '$z'),
def playGames(population):
from GUI import draw_board
global board
win = draw = stall = lose = 0
# Add rules to Rete
rete_net = Network()
for candidate in population:
p = add_rule_to_Rete(rete_net, candidate['rule'])
if p:
print('●', print_rule(candidate['rule']), end='\n')
# print(' (%d)' % length_of_rule(candidate['rule']))
candidate['p_node'] = p
# save_Rete_graph(rete_net, 'rete_0')
for n in range(1000): # play game N times
print("\t\tGame ", n, end='\r')
# Initialize board
for i in [0, 1, 2]:
for j in [0, 1, 2]:
if board[i][j] != ' ':
rete_net.remove_wme(WME(board[i][i], str(i), str(j)))
rete_net.add_wme(WME(' ', str(i), str(j)))
board[i][j] = ' '
CurrentPlayer = 'X' # In the future, may play against self
moves = [] # for recording played moves
for move in range(9): # Repeat playing moves in single game
# print(" move", move, end='; ')
if CurrentPlayer == 'X':
# collect all playable rules
playable = []
for candidate in population:
p0 = candidate['p_node']
if not p0:
continue
if p0.items:
DEBUG(len(p0.items), " instances")
for item in p0.items:
# item = random.choice(p0.items) # choose an instantiation randomly
# Question: are all instances the same?
# apply binding to rule's action (ie, post-condition)
if is_var(p0.postcondition.F2):
p0.postcondition.F2 = item.get_binding(p0.postcondition.F2)
if p0.postcondition.F2 is None:
p0.postcondition.F2 = str(random.randint(0,2))
if is_var(p0.postcondition.F3):
p0.postcondition.F3 = item.get_binding(p0.postcondition.F3)
if p0.postcondition.F3 is None:
p0.postcondition.F3 = str(random.randint(0,2))
DEBUG("production rule = ", print_rule(candidate['rule']))
DEBUG("chosen item = ", item)
DEBUG("postcond = ", p0.postcondition)
# Check if the square is empty
x = int(p0.postcondition.F2)
y = int(p0.postcondition.F3)
if board[x][y] == ' ':
playable.append(candidate)
candidate['fitness'] += 1.0
else:
candidate['fitness'] -= 1.0
# print(len(playable), "playable rules ", end='')
uniques = []
for candidate in playable:
if not uniques:
uniques.append(candidate)
continue
exists = False
for u in uniques:
if candidate['p_node'].postcondition == u['p_node'].postcondition:
exists = True
if not exists:
uniques.append(candidate)
# print("; unique moves =\x1b[31;1m", len(uniques), end='\x1b[0m\n')
if not uniques:
# print("No rules playable")
stall += 1
break # next game
# Choose a playable rule randomly
candidate = random.choice(uniques)
p0 = candidate['p_node']
x = int(p0.postcondition.F2)
y = int(p0.postcondition.F3)
board[x][y] = CurrentPlayer
# print(" played move: X(%d,%d)" % (x,y))
# remove old WME
rete_net.remove_wme(WME(' ', p0.postcondition.F2, p0.postcondition.F3))
# add new WME
rete_net.add_wme(WME(CurrentPlayer, p0.postcondition.F2, p0.postcondition.F3))
# **** record move: record the rule that is fired
moves.append(candidate)
else: # Player = 'O'
i,j = opponentPlay()
board[i][j] = 'O'
# print("Opponent move: O(%d,%d)" % (i,j))
# remove old WME
rete_net.remove_wme(WME(' ', str(i), str(j)))
# add new WME
rete_net.add_wme(WME('O', str(i), str(j)))
# printBoard() # this is text mode
draw_board(board) # graphics mode
# check if win / lose, assign rewards accordingly
winner = hasWinner()
if winner == ' ':
# let the same set of rules play again
# let opponent play (opponent = self? this may be implemented later)
CurrentPlayer = 'O' if CurrentPlayer == 'X' else 'X'
elif winner == '-':
# increase the scores of all played moves by 3.0
for candidate in moves:
candidate['fitness'] += 3.0
# print("Draw")
draw += 1
break # next game
elif winner == 'X':
# increase the scores of all played moves by 10.0
for candidate in moves:
candidate['fitness'] += 10.0
# print("X wins")
win += 1
break # next game
elif winner == 'O':
# decrease the scores of all played moves by 8.0
for candidate in moves:
candidate['fitness'] -= 8.0
# print("O wins")
lose += 1
break # next game
return win, draw, stall, lose
def playGames(population):
global board, moves, rete_net
win = draw = stall = lose = 0
# Add rules to Rete
rete_net = Network()
# print("\x1b[43m-----------------------------------------------\x1b[0m")
for candidate in population:
p = add_rule_to_Rete(rete_net, candidate['rule'])
if p:
print('●', print_rule(candidate['rule']), end='\n')
# print(' (%d)' % length_of_rule(candidate['rule']))
candidate['p_node'] = p
# save_Rete_graph(rete_net, 'rete_0')
for n in range(1000): # play game N times
print("\r\t\tGame ", n, end='\r')
# Initialize board
for i in [0, 1, 2]:
for j in [0, 1, 2]:
if board[i][j] != ' ':
rete_net.remove_wme(WME(board[i][i], str(i), str(j)))
rete_net.add_wme(WME(' ', str(i), str(j)))
board[i][j] = ' '
CurrentPlayer = 'X' # In the future, may play against self
moves = [] # for recording played moves
for move in range(9): # Repeat playing moves in single game
# print(" move", move, end='; ')
if CurrentPlayer == 'X':
if play_1_move(population, CurrentPlayer): # Stalled?
stall += 1
break # game-over, next game
else: # Player = 'O'
i, j = opponentPlay()
board[i][j] = 'O'
# print("Opponent move: O(%d,%d)" % (i,j))
# remove old WME
rete_net.remove_wme(WME(' ', str(i), str(j)))
# add new WME
rete_net.add_wme(WME('O', str(i), str(j)))
# printBoard() # this is text mode
# new_GUI.draw_board() # graphics mode
# check if win / lose, assign rewards accordingly
winner = hasWinner()
if winner == ' ':
# let the same set of rules play again
# let opponent play (opponent = self? this may be implemented later)
CurrentPlayer = 'O' if CurrentPlayer == 'X' else 'X'
elif winner == '-':
# increase the scores of all played moves by 3.0
for candidate in moves:
candidate['fitness'] += 3.0
# print("Draw")
draw += 1
break # next game
elif winner == 'X':
# increase the scores of all played moves by 10.0
for candidate in moves:
candidate['fitness'] += 10.0
# print("X wins")
win += 1
break # next game
elif winner == 'O':
# decrease the scores of all played moves by 8.0
for candidate in moves:
candidate['fitness'] -= 8.0
# print("O wins")
lose += 1
break # next game
return win, draw, stall, lose
def Evolve():
global maxGens, popSize, maxDepth, bouts, p_repro, crossRate, mutationRate
population = []
print("Generating population...")
for c in cache:
population.append({
'target' : c['target'],
'fitness' : fitness(c['target'])
})
print("Adding from cache:", len(cache))
for i in range(0, popSize - len(cache)):
print(i, '..', end='')
sys.stdout.flush()
# print "\tGenerating formula..."
target = generate_random_formula(maxDepth)
population.append({
'target' : target, \
'fitness' : fitness(target)})
print()
pop2 = sorted(population, key = lambda x : x['fitness'], reverse = False)
best = pop2[0]
rule = best.get('target')
print("\nExample logic rule:\n", print_tree(rule))
export_tree_as_graph(rule, "logic-rule")
print("Example rule written to file: logic-rule.png")
# plot_population(screen, pop2)
print("\n\x1b[32m——`—,—{\x1b[31;1m@\x1b[0m\n") # Genifer logo ——`—,—{@
# Feed logic formulas into Rete
rete_net = Network()
add_tree_to_Rete(rete_net, rule)
input("**** This program works till here....")
for gen in range(0, maxGens):
children = []
# print "\nGenerating children..."
while len(children) < popSize:
operation = random.uniform(0.0, 1.0)
p1 = tournament_selection(population, bouts)
c1 = {}
if operation < p_repro:
c1['target'] = copy_tree(p1['target'])
# c1['cond'] = copy_tree(p1['cond'])
elif operation < p_repro + crossRate:
p2 = tournament_selection(population, bouts)
c2 = {}
c1['target'],c2['target'] = crossover(p1['target'], p2['target'], maxDepth, terms)
# c1['cond'], c2['cond'] = crossover_cond(p1['cond'], p2['cond'], maxDepth, terms)
# print "***** crossed condition = ", print_tree(c1['cond'])
children.append(c2)
elif operation < p_repro + crossRate + mutationRate:
c1['target'] = mutation(p1['target'], maxDepth, arith_ops, terms)
# c1['cond'] = mutation_cond(p1['cond'], maxDepth, arith_ops, terms)
# print "***** mutated condition = ", print_tree(c1['cond'])
if len(children) < popSize:
children.append(c1)
# print "Evaluating children..."
for c in children:
# print "c's Condition = ", print_tree(c['cond'])
c['fitness'] = fitness(c['target'])
best['fitness'] = fitness(best['target'], None, 500)
# population = children
population = sorted(children, key = lambda x : x['fitness'], reverse = False)
# plot_population(screen, population)
quitting = False
pausing = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitting = True
elif event.type == pygame.KEYDOWN:
pausing = True
elif event.type == pygame.KEYUP:
pausing = False
while pausing:
for event in pygame.event.get():
if event.type == pygame.QUIT:
quitting = True
pausing = False
elif event.type == pygame.KEYUP:
pausing = False
print("[", gen, "]", end=' ')
print("best in pop =", round(population[0]['fitness'],2), "\tprevious best =", round(best['fitness'],2))
if population[0]['fitness'] <= best['fitness']:
best = population[0]
else:
population = [best] + population[:-1]
# if best['fitness'] == 0:
# break
return best
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
import os
from rete.common import Has, Rule, WME, Neg, Ncc, Token
from rete.network import Network
rete_net = Network()
c01 = Has('O', '$x', '$x')
c02 = Has('□', '$y', '$z')
c03 = Has('>', '$y', '$z')
p0 = rete_net.add_production(Rule(c01, c02, c03))
wmes = [
WME('X', '0', '2'),
WME('X', '1', '1'),
WME('X', '2', '1'),
WME('O', '0', '0'),
WME('O', '1', '0'),
WME('O', '1', '2'),
WME('O', '2', '2'),
WME('□', '0', '1'),
WME('□', '2', '0'),
]
for wme in wmes:
rete_net.add_wme(wme)
print("# of results = ", len(p0.items))