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)