def test_SmtEncoder_triplexer(self):
np.random.seed(1)
TOTAL_RUNS=5
#print ""
for iter in range(TOTAL_RUNS):
#print "Testing random triplexer [%d/%d]..." % (iter+1, TOTAL_RUNS),
# create a random triplexer
x = amnet.Variable(1, name='x')
a = 3 * (2 * np.random.rand(4) - 1)
b = 3 * (2 * np.random.rand(4) - 1)
c = 3 * (2 * np.random.rand(4) - 1)
d = 3 * (2 * np.random.rand(4) - 1)
e = 3 * (2 * np.random.rand(4) - 1)
f = 3 * (2 * np.random.rand(4) - 1)
phi_tri = amnet.atoms.triplexer(x, a, b, c, d, e, f)
def true_tri(fpin):
return amnet.atoms.fp_triplexer(fpin, a, b, c, d, e, f)
xvals = 50 * (2 * np.random.rand(100) - 1)
onvals = itertools.product(xvals, repeat=1)
self.validate_outputs(
phi=phi_tri,
onvals=onvals,
true_f=true_tri
)
def test_to_from_list(self):
x = amnet.Variable(2, name='x')
w = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([7, 8, 9])
y = amnet.Affine(
w,
x,
b
)
self.assertEqual(y.outdim, 3)
ylist = amnet.atoms.to_list(y)
self.assertEqual(len(ylist), y.outdim)
ytilde = amnet.atoms.from_list(ylist)
self.assertEqual(ytilde.outdim, y.outdim)
for (xv0, xv1) in product(self.floatvals, repeat=2):
xinp = np.array([xv0, xv1])
yv = y.eval(xinp)
ylv = np.array([yi.eval(xinp) for yi in ylist]).flatten() # note the flatten!
ytv = ytilde.eval(xinp)
self.assertAlmostEqual(norm(yv - ylv), 0)
self.assertAlmostEqual(norm(yv - ytv), 0)
def make_vgc(alpha):
# inputs
e_var = amnet.Variable(1, name='e')
edot_var = amnet.Variable(1, name='edot')
x = amnet.stack(e_var, edot_var)
# affine transformations
zero1 = amnet.atoms.make_const(np.zeros(1), x)
ae = amnet.Affine(np.array([[alpha, 0]]), x, np.zeros(1))
e = amnet.Affine(np.array([[1, 0]]), x, np.zeros(1))
neg_e = amnet.Affine(np.array([[-1, 0]]), x, np.zeros(1))
edot = amnet.Affine(np.array([[0, 1]]), x, np.zeros(1))
neg_edot = amnet.Affine(np.array([[0, -1]]), x, np.zeros(1))
return amnet.atoms.gate_or(amnet.atoms.gate_or(zero1, ae, neg_e, neg_edot),
ae, e, edot)
def test_SmtEncoder_dag(self):
xyz = amnet.Variable(3, name='xyz')
x = amnet.atoms.select(xyz, 0)
yz = amnet.Linear(
np.array([[0, 1, 0], [0, 0, 1]]),
xyz
)
maxyz = amnet.atoms.max_all(yz)
twoxp1 = amnet.Affine(
np.array([[2]]),
x,
np.array([1])
)
twox = amnet.atoms.add2(x, x)
threex = amnet.atoms.add2(x, twox)
fivexp1 = amnet.atoms.add2(twoxp1, threex)
phi = amnet.atoms.add2(fivexp1, maxyz)
def true_dag(fpin):
x, y, z = fpin
return 5*x + 1 + max(y, z)
self.validate_outputs(
phi=phi,
onvals=itertools.product(self.floatvals2, repeat=3),
true_f=true_dag
)
def test_max_all_max_aff(self):
x = amnet.Variable(4, name='x')
w = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]])
b = np.array([1.1, 1.2, 1.3])
y = amnet.Affine(
w,
x,
b
)
max_y = amnet.atoms.max_all(y)
maff = amnet.atoms.max_aff(w, b, x)
def true_max_aff(xinp):
return np.max(np.dot(w, xinp) + b)
for xv in itertools.product(self.floatvals2, repeat=4):
xinp = np.array(xv)
tv = true_max_aff(xinp)
max_y_v = max_y.eval(xinp)
maff_v = maff.eval(xinp)
self.assertAlmostEqual(norm(tv - max_y_v), 0)
self.assertAlmostEqual(norm(tv - maff_v), 0)
def make_vgc(alpha):
# inputs
x = amnet.Variable(2, name='x')
# affine transformations
zero1 = amnet.Constant(x, np.zeros(1))
e = amnet.atoms.select(x, 0)
edot = amnet.atoms.select(x, 1)
ae = amnet.Linear(np.array([[alpha, 0]]), x)
neg_e = amnet.Linear(np.array([[-1, 0]]), x)
neg_edot = amnet.Linear(np.array([[0, -1]]), x)
or0 = amnet.atoms.gate_or(zero1, ae, neg_e, neg_edot)
or1 = amnet.atoms.gate_or(or0, ae, e, edot)
# create naming context of the retval
ctx = amnet.vis.NamingContext(or1)
ctx.rename(x, 'x')
ctx.rename(zero1, 'zero')
ctx.rename(e, 'e')
ctx.rename(edot, 'edot')
ctx.rename(ae, 'ae')
ctx.rename(neg_e, 'neg_e')
ctx.rename(neg_edot, 'neg_edot')
ctx.rename(or0, 'or0')
ctx.rename(or1, 'or1')
return or1, ctx
def test_stack(self):
x = amnet.Variable(3, name='x')
w1 = np.array([[1, -2, 3]])
b1 = np.zeros(1)
w2 = np.array([[-5, 6, -7], [-8, 9, 10]])
b2 = np.array([11, -12])
w3 = np.array([[7, 8, 9]])
b3 = np.array([-1])
y1 = amnet.Linear(w1, x)
y2 = amnet.Affine(w2, x, b2)
y3 = amnet.Affine(w3, x, b3)
y4 = x
ystack = amnet.atoms.from_list([y1, y2, y3, y4])
self.assertEqual(ystack.outdim, 4+3)
self.assertEqual(ystack.indim, 3)
def ystack_true(xinp):
y1v = np.dot(w1, xinp) + b1
y2v = np.dot(w2, xinp) + b2
y3v = np.dot(w3, xinp) + b3
y4v = xinp
return np.concatenate((y1v, y2v, y3v, y4v), axis=0)
for (xv0, xv1, xv2) in product(self.floatvals2, repeat=3):
xinp = np.array([xv0, xv1, xv2])
ysv = ystack.eval(xinp)
ytv = ystack_true(xinp)
self.assertAlmostEqual(norm(ysv - ytv), 0)
def test_select(self):
x = amnet.Variable(2, name='x')
x0 = amnet.atoms.select(x, 0)
x1 = amnet.atoms.select(x, 1)
for (xv0, xv1) in product(self.floatvals, repeat=2):
xinp = np.array([xv0, xv1])
self.assertEqual(x0.eval(xinp), xv0)
self.assertEqual(x1.eval(xinp), xv1)
def test_SmtEncoder_relu_2(self):
x = amnet.Variable(3, name='x')
y = amnet.atoms.relu(x)
def true_relu(fpin):
return np.maximum(fpin, 0)
self.validate_outputs(
phi=y,
onvals=itertools.product(self.floatvals2, repeat=y.indim),
true_f=true_relu
)
def test_relu(self):
x = amnet.Variable(4, name='x')
y = amnet.Variable(1, name='y')
phi_relu = amnet.atoms.relu(x)
phi_reluy = amnet.atoms.relu(y)
# true relu
def relu(x): return np.maximum(x, 0)
for xv,yv,zv,wv in itertools.product(self.floatvals2, repeat=4):
xyzwv = np.array([xv, yv, zv, wv])
r = phi_relu.eval(xyzwv) # 4-d relu of x
s = relu(xyzwv)
self.assertTrue(len(r) == 4)
self.assertTrue(len(s) == 4)
self.assertTrue(all(r == s))
for yv in self.floatvals:
r = phi_reluy.eval(np.array([yv])) # 1-d relu of y
s = relu(np.array([yv]))
self.assertEqual(r, s)
def test_SmtEncoder_gates(self):
xy_z1z2 = amnet.Variable(2+2+1+1, name='xyz1z2')
x = amnet.Linear(
np.eye(2, 6, 0),
xy_z1z2
)
y = amnet.Linear(
np.eye(2, 6, 2),
xy_z1z2
)
z1 = amnet.atoms.select(xy_z1z2, 4)
z2 = amnet.atoms.select(xy_z1z2, 5)
phi_and = amnet.atoms.gate_and(x, y, z1, z2)
phi_or = amnet.atoms.gate_or(x, y, z1, z2)
phi_xor = amnet.atoms.gate_xor(x, y, z1, z2)
phi_not = amnet.atoms.gate_not(x, y, z1)
# check dimensions
self.assertEqual(xy_z1z2.outdim, 6)
self.assertEqual(x.outdim, 2)
self.assertEqual(y.outdim, 2)
self.assertEqual(z1.outdim, 1)
self.assertEqual(z2.outdim, 1)
self.assertEqual(phi_and.outdim, 2)
self.assertEqual(phi_or.outdim, 2)
self.assertEqual(phi_xor.outdim, 2)
self.assertEqual(phi_not.outdim, 2)
# true gate functions
def true_and(fpin):
return fpin[0:2] if (fpin[4] <= 0 and fpin[5] <= 0) else fpin[2:4]
def true_or(fpin):
return fpin[0:2] if (fpin[4] <= 0 or fpin[5] <= 0) else fpin[2:4]
def true_xor(fpin):
return fpin[0:2] if ((fpin[4] <= 0) != (fpin[5] <= 0)) else fpin[2:4]
def true_not(fpin): # ignores last input
return fpin[2:4] if (fpin[4] <= 0) else fpin[0:2]
# evaluate
vals = np.array([1, -2, -3, 4])
sels = itertools.product([-1, 0, 1], repeat=2)
onvals = [np.concatenate((vals, sel), axis=0) for sel in sels]
self.validate_outputs(phi=phi_and, onvals=onvals, true_f=true_and)
self.validate_outputs(phi=phi_or, onvals=onvals, true_f=true_or)
self.validate_outputs(phi=phi_xor, onvals=onvals, true_f=true_xor)
self.validate_outputs(phi=phi_not, onvals=onvals, true_f=true_not)
def test_SmtEncoder_min_all_2(self):
xy = amnet.Variable(2, name='xy')
phi_min2 = amnet.atoms.min_all(xy)
self.assertEqual(phi_min2.indim, 2)
def true_min2(fpin):
x, y = fpin
return min(x, y)
self.validate_outputs(
phi=phi_min2,
onvals=itertools.product(self.floatvals, repeat=phi_min2.indim),
true_f=true_min2
)
def test_SmtEncoder_min_all_3_small(self):
xyz = amnet.Variable(3, name='xy')
phi_min3 = amnet.atoms.min_all(xyz)
self.assertEqual(phi_min3.indim, 3)
def true_min3(fpin):
x, y, z = fpin
return min(x, y, z)
self.validate_outputs(
phi=phi_min3,
onvals=itertools.product(self.floatvals2, repeat=phi_min3.indim),
true_f=true_min3
)
def test_SmtEncoder_add_all(self):
xyz = amnet.Variable(3, name='xyz')
phi_add = amnet.atoms.add_all(xyz)
self.assertEqual(phi_add.outdim, 1)
self.assertEqual(phi_add.indim, 3)
def true_add(fpin):
return sum(fpin)
self.validate_outputs(
phi=phi_add,
onvals=itertools.product(self.floatvals2, repeat=phi_add.indim),
true_f=true_add
)
def stability_search1(self):
#Ad = self.Ad_osc
Ad = self.Ad_met
(n, _) = Ad.shape
assert n == 2
xsys = amnet.Variable(n, name='xsys')
phi = amnet.Affine(
Ad,
xsys,
np.zeros(n)
)
# look for a Lyapunov function
#amnet.lyap.stability_search1(phi, xsys, 10)
amnet.lyap.stability_search1(phi, xsys, 4) # enough for Metzler sys
def test_SmtEncoder_mu_small(self):
xyz = amnet.Variable(3, name='xyz')
x = amnet.atoms.select(xyz, 0)
y = amnet.atoms.select(xyz, 1)
z = amnet.atoms.select(xyz, 2)
w = amnet.Mu(x, y, z)
def true_mu(fpin):
x, y, z = fpin
return x if z <= 0 else y
self.validate_outputs(
phi=w,
onvals=itertools.product(self.floatvals2, repeat=w.indim),
true_f=true_mu
)
def test_triplexer(self):
x = amnet.Variable(1, name='xv')
np.random.seed(1)
for _ in range(10):
a = 3 * (2 * np.random.rand(4) - 1)
b = 3 * (2 * np.random.rand(4) - 1)
c = 3 * (2 * np.random.rand(4) - 1)
d = 3 * (2 * np.random.rand(4) - 1)
e = 3 * (2 * np.random.rand(4) - 1)
f = 3 * (2 * np.random.rand(4) - 1)
phi_tri = amnet.atoms.triplexer(x, a, b, c, d, e, f)
xvals = 100 * (2 * np.random.rand(1000) - 1)
for xv in xvals:
self.assertEqual(phi_tri.eval(np.array([xv])),
amnet.atoms.fp_triplexer(xv, a, b, c, d, e, f))
def test_SmtEncoder_identity(self):
x = amnet.Variable(2, name='x')
w = np.array([[1, 2], [3, 4]])
b = np.array([-1, -1])
y = amnet.Affine(w, x, b)
z = amnet.atoms.identity(y)
self.assertEqual(y.outdim, 2)
self.assertEqual(z.outdim, 2)
self.assertEqual(z.indim, 2)
def true_z(fpin):
return np.dot(w, fpin) + b
self.validate_outputs(
phi=z,
onvals=itertools.product(self.floatvals, repeat=z.indim),
true_f=true_z
)
def test_disprove_maxaff_local_lyapunov(self):
# a simple system
Ad = self.Ad_diag
(n, _) = Ad.shape
assert n == 2
xsys = amnet.Variable(n, name='xsys')
phi = amnet.Affine(
Ad,
xsys,
np.zeros(n)
)
# a simple Lyapunov function
Astar = np.array([[1, 1], [1, -1], [-1, 1], [-1, -1]])
bstar = np.zeros(4)
xc = amnet.lyap.find_local_counterexample(phi, xsys, Astar, bstar)
# simple Lyapunov function works
self.assertTrue(xc is None)
def test_identity(self):
x = amnet.Variable(2, name='x')
w = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([7, 8, 9])
y = amnet.Affine(
w,
x,
b
)
self.assertEqual(y.outdim, 3)
z = amnet.atoms.neg(y)
self.assertEqual(z.outdim, y.outdim)
def aff(x): return np.dot(w, x) + b
for (xv0, xv1) in product(self.floatvals, repeat=2):
xinp = np.array([xv0, xv1])
yv = y.eval(xinp)
zv = z.eval(xinp)
self.assertAlmostEqual(norm(yv - aff(xinp)), 0)
self.assertAlmostEqual(norm(zv + aff(xinp)), 0)
def test_SmtEncoder_add_list(self):
xyz = amnet.Variable(2+2+2, name='xyz')
x = amnet.Linear(np.eye(2, 6, 0), xyz)
y = amnet.Linear(np.eye(2, 6, 2), xyz)
z = amnet.Linear(np.eye(2, 6, 4), xyz)
phi_add_list = amnet.atoms.add_list([x, y, z])
self.assertEqual(x.outdim, 2)
self.assertEqual(y.outdim, 2)
self.assertEqual(z.outdim, 2)
self.assertEqual(phi_add_list.outdim, 2)
self.assertEqual(phi_add_list.indim, 6)
def true_add(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4:6]
return x + y + z
self.validate_outputs(
phi=phi_add_list,
onvals=itertools.product(self.floatvals3, repeat=phi_add_list.indim),
true_f=true_add
)
def test_max2_min2(self):
xy = amnet.Variable(6, name='xy')
x = amnet.Linear(
np.eye(3,6,0),
xy
)
y = amnet.Linear(
np.eye(3,6,3),
xy
)
max_xy = amnet.atoms.max2(x, y)
min_xy = amnet.atoms.min2(x, y)
def true_max2(xinp, yinp):
return np.maximum(xinp, yinp)
def true_min2(xinp, yinp):
return np.minimum(xinp, yinp)
for xyv in itertools.product(self.floatvals2, repeat=6):
xyinp = np.array(xyv)
xinp = xyinp[:3]
yinp = xyinp[3:]
max_xy_tv = true_max2(xinp, yinp)
max_xy_v = max_xy.eval(xyinp)
min_xy_tv = true_min2(xinp, yinp)
min_xy_v = min_xy.eval(xyinp)
self.assertEqual(len(max_xy_tv), 3)
self.assertEqual(len(max_xy_v), 3)
self.assertAlmostEqual(norm(max_xy_v - max_xy_tv), 0)
self.assertEqual(len(min_xy_tv), 3)
self.assertEqual(len(min_xy_v), 3)
self.assertAlmostEqual(norm(min_xy_v - min_xy_tv), 0)
import numpy as np import amnet import amnet.vis np.random.seed(1) # define a triplexer x = amnet.Variable(1, name='x') a = 3 * (2 * np.random.rand(4) - 1) b = 3 * (2 * np.random.rand(4) - 1) c = 3 * (2 * np.random.rand(4) - 1) d = 3 * (2 * np.random.rand(4) - 1) e = 3 * (2 * np.random.rand(4) - 1) f = 3 * (2 * np.random.rand(4) - 1) phi_tri = amnet.atoms.triplexer(x, a, b, c, d, e, f) # visualize triplexer dot = amnet.vis.amn2gv(phi_tri, title='phi_tri(var0)') dot.render(filename='phi_tri.gv', directory='vis') print dot
import numpy as np import amnet import amnet.vis # a two-dimensional input variable x = amnet.Variable(2, name='x') # choose components x0 = amnet.Linear(np.array([[1, 0]]), x) x1 = amnet.Linear(np.array([[0, 1]]), x) # subtract x0 from x1 z = amnet.Linear(np.array([[-1, 1]]), x) # maximum of x0 and x1 phimax = amnet.Mu(x0, x1, z) print phimax print phimax.eval([1, -2]) # returns: 1 # visualize dot = amnet.vis.amn2gv(phimax, title='max2(var0)') dot.render(filename='max.gv', directory='vis') print dot
def test_SmtEncoder_cmp(self):
xyz = amnet.Variable(2+2+1, name='xyz')
x = amnet.Linear(
np.eye(2, 5, 0),
xyz
)
y = amnet.Linear(
np.eye(2, 5, 2),
xyz
)
z = amnet.atoms.select(xyz, 4)
phi_eq = amnet.atoms.cmp_eq(x, y, z)
phi_neq = amnet.atoms.cmp_neq(x, y, z)
phi_ge = amnet.atoms.cmp_ge(x, y, z)
phi_gt = amnet.atoms.cmp_gt(x, y, z)
phi_le = amnet.atoms.cmp_le(x, y, z)
phi_lt = amnet.atoms.cmp_lt(x, y, z)
# check dimensions
self.assertEqual(xyz.outdim, 5)
self.assertEqual(x.outdim, 2)
self.assertEqual(y.outdim, 2)
self.assertEqual(z.outdim, 1)
self.assertEqual(phi_eq.outdim, 2)
self.assertEqual(phi_neq.outdim, 2)
self.assertEqual(phi_ge.outdim, 2)
self.assertEqual(phi_gt.outdim, 2)
self.assertEqual(phi_le.outdim, 2)
self.assertEqual(phi_lt.outdim, 2)
# true cmp functions
def true_eq(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4]
return x if z == 0 else y
def true_neq(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4]
return x if z != 0 else y
def true_ge(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4]
return x if z >= 0 else y
def true_gt(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4]
return x if z > 0 else y
def true_le(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4]
return x if z <= 0 else y
def true_lt(fpin):
x, y, z = fpin[0:2], fpin[2:4], fpin[4]
return x if z < 0 else y
# evaluate
vals = np.array([1, -2, -3, 4])
sels = itertools.product([-1.1, -0.5, 0, 0.0, 0.01, 1, 12.0], repeat=1)
onvals = [np.concatenate((vals, sel), axis=0) for sel in sels]
self.validate_outputs(phi=phi_eq, onvals=onvals, true_f=true_eq)
self.validate_outputs(phi=phi_neq, onvals=onvals, true_f=true_neq)
self.validate_outputs(phi=phi_ge, onvals=onvals, true_f=true_ge)
self.validate_outputs(phi=phi_gt, onvals=onvals, true_f=true_gt)
self.validate_outputs(phi=phi_le, onvals=onvals, true_f=true_le)
self.validate_outputs(phi=phi_lt, onvals=onvals, true_f=true_lt)
