def test_network_no_duplicate_input(self):
ex = None
try:
model.Network(model.Input("a"), model.Input("a"))
except ValueError as ex:
pass
self.assertIsNotNone(ex)
def test_update(self):
a = model.Input("a")
b = model.Input("b")
c = model.Input("c")
d = model.Input("d")
e = model.Input("e")
f = model.Input("f")
g = model.Input("g")
h = model.Input("h")
net = model.Network(
model.AndNeuron(
model.AndNeuron(a, b),
model.AndNeuron(c, d)
),
model.AndNeuron(
model.AndNeuron(e, f),
model.AndNeuron(g, h)
)
)
states = net.update(a=1, b=0, c=1, d=0, e=1, f=0, g=1, h=0)
self.assertEquals(net["a"].state, 1)
self.assertEquals(net["b"].state, 0)
self.assertEquals(net["c"].state, 1)
self.assertEquals(net["d"].state, 0)
self.assertEquals(net["e"].state, 1)
self.assertEquals(net["f"].state, 0)
self.assertEquals(net["g"].state, 1)
self.assertEquals(net["h"].state, 0)
self.assertEquals(states, (0, 0))
states = net.update(a=0, b=1, c=0, d=1, e=0, f=1, g=0, h=1)
self.assertEquals(net["a"].state, 0)
self.assertEquals(net["b"].state, 1)
self.assertEquals(net["c"].state, 0)
self.assertEquals(net["d"].state, 1)
self.assertEquals(net["e"].state, 0)
self.assertEquals(net["f"].state, 1)
self.assertEquals(net["g"].state, 0)
self.assertEquals(net["h"].state, 1)
self.assertEquals(states, (0, 0))
states = net.update(a=1, b=1, c=1, d=1, e=0, f=0, g=0, h=0)
self.assertEquals(net["a"].state, 1)
self.assertEquals(net["b"].state, 1)
self.assertEquals(net["c"].state, 1)
self.assertEquals(net["d"].state, 1)
self.assertEquals(net["e"].state, 0)
self.assertEquals(net["f"].state, 0)
self.assertEquals(net["g"].state, 0)
self.assertEquals(net["h"].state, 0)
self.assertEquals(states, (1, 0))
states = net.update(a=0, b=0, c=0, d=0, e=1, f=1, g=1, h=1)
self.assertEquals(net["a"].state, 0)
self.assertEquals(net["b"].state, 0)
self.assertEquals(net["c"].state, 0)
self.assertEquals(net["d"].state, 0)
self.assertEquals(net["e"].state, 1)
self.assertEquals(net["f"].state, 1)
self.assertEquals(net["g"].state, 1)
self.assertEquals(net["h"].state, 1)
self.assertEquals(states, (0, 1))
def test_getitem(self):
a = model.Input("a")
b = model.Input("b")
c = model.Input("c")
d = model.Input("d")
e = model.Input("e")
f = model.Input("f")
g = model.Input("g")
h = model.Input("h")
and_aa = model.AndNeuron(a, b)
and_ab = model.AndNeuron(c, d)
and_a = model.AndNeuron(and_aa, and_ab)
and_ba = model.AndNeuron(e, f)
and_bb = model.AndNeuron(g, h)
and_b = model.AndNeuron(and_ba, and_bb)
net = model.Network(and_a, and_b)
self.assertEquals(net["a"], a)
self.assertEquals(net["b"], b)
self.assertEquals(net["c"], c)
self.assertEquals(net["d"], d)
self.assertEquals(net["e"], e)
self.assertEquals(net["f"], f)
self.assertEquals(net["g"], g)
self.assertEquals(net["h"], h)
self.assertEquals(net[0], and_a)
self.assertEquals(net[1], and_b)
def test_gather_inputs_collects_inputs(self):
a = model.Input("a")
b = model.Input("b")
c = model.Input("c")
d = model.Input("d")
e = model.Input("e")
f = model.Input("f")
g = model.Input("g")
h = model.Input("h")
net = model.Network(
model.AndNeuron(
model.AndNeuron(a, b),
model.AndNeuron(c, d)
),
model.AndNeuron(
model.AndNeuron(e, f),
model.AndNeuron(g, h)
)
)
self.assertEquals(len(net.inputs), 8)
self.assertEquals(net.inputs["a"], a)
self.assertEquals(net.inputs["b"], b)
self.assertEquals(net.inputs["c"], c)
self.assertEquals(net.inputs["d"], d)
self.assertEquals(net.inputs["e"], e)
self.assertEquals(net.inputs["f"], f)
self.assertEquals(net.inputs["g"], g)
self.assertEquals(net.inputs["h"], h)
def test_simple_net(self):
"""
a -\
AND \
b -/ \
AND ->
c -\ /
AND /
d -/
"""
a = model.Input("a")
b = model.Input("b")
g1 = model.AndNeuron(a, b)
c = model.Input("c")
d = model.Input("d")
g2 = model.AndNeuron(c, d)
final = model.AndNeuron(g1, g2)
def try_states(_a, _b, _c, _d, expected):
a.state = _a
b.state = _b
g1.update()
c.state = _c
d.state = _d
g2.update()
final.update()
self.assertEquals(final.state, expected,
"%s should result in %s" %
((_a, _b, _c, _d), expected))
try_states(0, 0, 0, 0, 0)
try_states(0, 0, 0, 1, 0)
try_states(0, 0, 1, 0, 0)
try_states(0, 0, 1, 1, 0)
try_states(0, 1, 0, 0, 0)
try_states(0, 1, 0, 1, 0)
try_states(0, 1, 1, 0, 0)
try_states(0, 1, 1, 1, 0)
try_states(1, 0, 0, 0, 0)
try_states(1, 0, 0, 1, 0)
try_states(1, 0, 1, 0, 0)
try_states(1, 0, 1, 1, 0)
try_states(1, 1, 0, 0, 0)
try_states(1, 1, 0, 1, 0)
try_states(1, 1, 1, 0, 0)
try_states(1, 1, 1, 1, 1)
def test_network_named_input(self):
ex = None
try:
model.Network(model.Input())
except ValueError as ex:
pass
self.assertIsNotNone(ex)
def test_xor_network(self):
a = model.Input("a")
b = model.Input("b")
xor = network.XorNetwork(a, b)
state = xor.update(a=0, b=0)
self.assertEqual(state, (0, ))
state = xor.update(a=1, b=1)
self.assertEqual(state, (0, ))
state = xor.update(a=1, b=0)
self.assertEqual(state, (1, ))
state = xor.update(a=0, b=1)
self.assertEqual(state, (1, ))
def test_full_adder(self):
cin = model.Input("cin")
a = model.Input("a")
b = model.Input("b")
full_adder = network.FullAdder(cin, a, b)
state = full_adder.update(cin=0, a=0, b=0)
self.assertEqual(state, (0, 0))
self.assertEqual(full_adder.output.state, 0)
self.assertEqual(full_adder.carry.state, 0)
state = full_adder.update(cin=0, a=1, b=1)
self.assertEqual(state, (0, 1))
self.assertEqual(full_adder.output.state, 0)
self.assertEqual(full_adder.carry.state, 1)
state = full_adder.update(cin=0, a=1, b=0)
self.assertEqual(state, (1, 0))
self.assertEqual(full_adder.output.state, 1)
self.assertEqual(full_adder.carry.state, 0)
state = full_adder.update(cin=0, a=0, b=1)
self.assertEqual(state, (1, 0))
self.assertEqual(full_adder.output.state, 1)
self.assertEqual(full_adder.carry.state, 0)
state = full_adder.update(cin=1, a=0, b=0)
self.assertEqual(state, (1, 0))
self.assertEqual(full_adder.output.state, 1)
self.assertEqual(full_adder.carry.state, 0)
state = full_adder.update(cin=1, a=1, b=1)
self.assertEqual(state, (1, 1))
self.assertEqual(full_adder.output.state, 1)
self.assertEqual(full_adder.carry.state, 1)
state = full_adder.update(cin=1, a=1, b=0)
self.assertEqual(state, (0, 1))
self.assertEqual(full_adder.output.state, 0)
self.assertEqual(full_adder.carry.state, 1)
state = full_adder.update(cin=1, a=0, b=1)
self.assertEqual(state, (0, 1))
self.assertEqual(full_adder.output.state, 0)
self.assertEqual(full_adder.carry.state, 1)
def test_basic_perceptron(self):
a = model.Input("a")
b = model.Input("b")
c = model.Input("c")
d = model.Input("d")
p = perceptron.Perceptron((a, b, c, d), (0, 0, 0, 0), 1)
n = model.Network(p)
def get_expected(a_in, b_in, c_in, d_in):
# The output should be true iff a_in is true and b_in is true
return 1 if a_in == 1 and b_in == 1 else 0
def learn(a_in, b_in, c_in, d_in, batch_size=2500, learning_rate=0.25):
e = get_expected(a_in, b_in, c_in, d_in)
for dummy in xrange(batch_size):
n.update(a=a_in, b=b_in, c=c_in, d=d_in)
p.train(e, learning_rate)
def test(a_in, b_in, c_in, d_in):
state, = n.update(a=a_in, b=b_in, c=c_in, d=d_in)
return state
for _a in (0, 1):
for _b in (0, 1):
for _c in (0, 1):
for _d in (0, 1):
learn(_a, _b, _c, _d)
n_tests = 0
n_successes = 0
for _a in (0, 1):
for _b in (0, 1):
for _c in (0, 1):
for _d in (0, 1):
n_tests += 1
value = test(_a, _b, _c, _d)
expected = get_expected(_a, _b, _c, _d)
if value == expected:
n_successes += 1
self.assertEqual(n_tests, n_successes)
self.assertEqual(p.weights, [0.5, 0.5, 0, 0])
def test_not_neuron(self):
a = model.Input("a")
gate = model.NotNeuron(a)
a.state = 0
gate.update()
self.assertEquals(gate.state, 1)
a.state = 1
gate.update()
self.assertEquals(gate.state, 0)
def test_nand_neuron(self):
a = model.Input("a")
b = model.Input("b")
gate = model.NandNeuron(a, b)
a.state = 0
b.state = 0
gate.update()
self.assertEquals(gate.state, 1)
a.state = 1
b.state = 0
gate.update()
self.assertEquals(gate.state, 1)
a.state = 0
b.state = 1
gate.update()
self.assertEquals(gate.state, 1)
a.state = 1
b.state = 1
gate.update()
self.assertEquals(gate.state, 0)
def test_half_adder(self):
a = model.Input("a")
b = model.Input("b")
half_adder = network.HalfAdder(a, b)
state = half_adder.update(a=0, b=0)
self.assertEqual(state, (0, 0))
self.assertEqual(half_adder.output.state, 0)
self.assertEqual(half_adder.carry.state, 0)
state = half_adder.update(a=1, b=1)
self.assertEqual(state, (0, 1))
self.assertEqual(half_adder.output.state, 0)
self.assertEqual(half_adder.carry.state, 1)
state = half_adder.update(a=1, b=0)
self.assertEqual(state, (1, 0))
self.assertEqual(half_adder.output.state, 1)
self.assertEqual(half_adder.carry.state, 0)
state = half_adder.update(a=0, b=1)
self.assertEqual(state, (1, 0))
self.assertEqual(half_adder.output.state, 1)
self.assertEqual(half_adder.carry.state, 0)
def test_iter_order(self):
a = model.Input("a")
b = model.Input("b")
c = model.Input("c")
d = model.Input("d")
e = model.Input("e")
f = model.Input("f")
g = model.Input("g")
h = model.Input("h")
and_aa = model.AndNeuron(a, b)
and_ab = model.AndNeuron(c, d)
and_a = model.AndNeuron(and_aa, and_ab)
and_ba = model.AndNeuron(e, f)
and_bb = model.AndNeuron(g, h)
and_b = model.AndNeuron(and_ba, and_bb)
net = model.Network(and_a, and_b)
expected = [a, b, and_aa, c, d, and_ab, and_a, e, f, and_ba, g, h,
and_bb, and_b]
self.assertListEqual(list(net), expected)
def test_network_repr(self):
a = model.Network(model.Input("a"))
self.assertIsNotNone(repr(a))
def test_input_repr(self):
a = model.Input()
self.assertIsNotNone(repr(a))
