def vdp_pwa2sal(pwa_rep, module_name):
init_set = C.IntervalCons(np.array([-0.4, -0.4]), np.array([0.4, 0.4]))
prop = C.IntervalCons(np.array([-1, -6.5]), np.array([-0.7, -5.6]))
sal_trans_sys = st.SALTransSys(module_name, 2, init_set, prop)
for sub_model in pwa_rep:
g = st.Guard(sub_model.p.C, sub_model.p.d)
r = st.Reset(sub_model.m.A, sub_model.m.b)
t = st.Transition(g, r)
sal_trans_sys.add_transition(t)
return sal_trans_sys
def error(self, X, Y):
"""error
Parameters
----------
X : Test input
Y : Test Output
Returns
-------
Computes signed error against passed in test samples.
Sound error interval vector (non-symmeteric).
The interal must be added and NOT subtracted to make a sound
model. e.g. Y_sound = A*X + e
or,
predict(X) + e_l <= Y_sound <= predict(X) + e_h
Y_sound = predict(X) + [e_l, e_h]
Notes
------
Computes interval vector e = Y_true - Y_predict, such that
the interval is sound w.r.t. to passed in test samples
"""
Yp = self.predict(X)
assert (Y.shape == Yp.shape)
delta = Y - Yp
max_e = np.max(delta, axis=0)
min_e = np.min(delta, axis=0)
return cons.IntervalCons(min_e, max_e)
def ival_constraints(cell, eps):
"""ival_constraints
Parameters
----------
cell : cell id tuple
eps : grid eps
Returns
-------
Notes
------
Cell is defined as left closed and right open: [ )
This is achieved by subtracting a small % of eps from the cell's
'right' boundary (ic.h)
"""
tol = (1e-5) * np.array(eps) # 0.001% of eps
cell_coordinates = np.array(cell) * eps
ival_l = cell_coordinates
ival_h = cell_coordinates + eps - tol
return cons.IntervalCons(ival_l, ival_h)
'''
parses the file bbal.log
which took 4.8 days to compute
real 17391m21.106s
user 17260m31.784s
sys 125m51.456s
'''
import constraints as C
import fileops as fops
fr = fops.ReadLine('./bbal.log')
s = 'dummy'
x = C.IntervalCons((4.9, ), (5.0, ))
while s:
if s.strip().find('1.0*x3 \\in ') == 0:
ss = s.strip().replace('1.0*x3 \\in ', '')
ic = C.IntervalCons(*map(lambda x: (float(x), ), ss[1:-1].split(',')))
if x & ic is not None:
print ic
s = fr.readline()
def parse(file_path, plant_pvt_init_data):
test_des_file = file_path
path = fp.get_abs_base_path(file_path)
sys_name = fp.split_filename_ext(fp.get_file_name_from_path(file_path))[0]
test_dir = fp.get_abs_base_path(test_des_file)
SYS.path.append(test_dir)
try:
sut = imp.load_source('test_des', test_des_file)
except IOError as e:
print('File not found: {}'.format(test_des_file))
raise e
sut.plant_pvt_init_data = plant_pvt_init_data
try:
assert (len(sut.initial_set) == 2)
assert (len(sut.error_set) == 2)
assert (len(sut.ci) == 2)
assert (len(sut.pi) == 2)
assert (len(sut.ci[0]) == len(sut.ci[1]))
assert (len(sut.pi[0]) == len(sut.pi[1]))
assert (len(sut.initial_set[0]) == len(sut.initial_set[1]))
assert (len(sut.error_set[0]) == len(sut.error_set[1]))
assert (len(sut.initial_set[0]) == len(sut.error_set[0]))
assert (len(sut.initial_set[0]) == len(sut.grid_eps))
num_dims = NumDims(
si=len(sut.initial_controller_integer_state),
sf=len(sut.initial_controller_float_state),
s=len(sut.initial_controller_integer_state) +
len(sut.initial_controller_float_state),
x=len(sut.initial_set[0]),
u=sut.num_control_inputs,
ci=len(sut.ci[0]),
pi=len(sut.pi[0]),
d=len(sut.initial_discrete_state),
pvt=0,
)
if not hasattr(sut, 'ci_grid_eps') or len(sut.ci_grid_eps) == 0:
sut.ci_grid_eps = []
# if hasattr(sut, 'ci_grid_eps'):
# if len(sut.ci_grid_eps) == 0:
# sut.ci_grid_eps = None
# else:
# sut.ci_grid_eps = None
if not hasattr(sut, 'pi_grid_eps') or len(sut.pi_grid_eps) == 0:
sut.pi_grid_eps = []
# if hasattr(sut, 'pi_grid_eps'):
# if len(sut.pi_grid_eps) == 0:
# sut.pi_grid_eps = None
# else:
# sut.pi_grid_eps = None
if num_dims.ci == 0:
ci = None
else:
ci = cns.IntervalCons(np.array(sut.ci[0]), np.array(sut.ci[1]))
if num_dims.pi == 0:
pi = None
else:
pi = cns.IntervalCons(np.array(sut.pi[0]), np.array(sut.pi[1]))
assert ((pi is None and sut.pi_grid_eps == [])
or (pi is not None and sut.pi_grid_eps != []))
assert ((ci is None and sut.ci_grid_eps == [])
or (ci is not None and sut.ci_grid_eps != []))
if pi is not None:
assert (len(sut.pi[0]) == len(sut.pi_grid_eps))
if ci is not None:
assert (len(sut.ci[0]) == len(sut.ci_grid_eps))
plant_config_dict = {
'plant_description': sut.plant_description,
'plant_path': sut.plant_path,
#'refinement_factor': sut.refinement_factor,
'eps': np.array(sut.grid_eps, dtype=float),
#'pi_eps': np.array(sut.pi_grid_eps, dtype=float),
'num_samples': int(sut.num_samples),
'delta_t': float(sut.delta_t),
#'type': 'string',
'type': 'value',
}
#print(plant_config_dict)
#for k, d in plant_config_dict.iteritems():
# plant_config_dict[k] = str(d)
# TODO: fix the list hack, once the controller ifc matures
init_cons = cns.IntervalCons(np.array(sut.initial_set[0]),
np.array(sut.initial_set[1]))
init_cons_list = [init_cons]
final_cons = cns.IntervalCons(np.array(sut.error_set[0]),
np.array(sut.error_set[1]))
T = sut.T
delta_t = sut.delta_t
if sut.controller_path is not None:
controller_object_str = fp.split_filename_ext(
sut.controller_path)[0]
controller_path_dir_path = fp.construct_path(
sut.controller_path_dir_path, path)
else:
controller_object_str = None
controller_path_dir_path = None
initial_discrete_state = sut.initial_discrete_state
initial_controller_state = (sut.initial_controller_integer_state +
sut.initial_controller_float_state)
MAX_ITER = sut.MAX_ITER
num_segments = int(np.ceil(T / delta_t))
controller_path = sut.controller_path
plant_pvt_init_data = sut.plant_pvt_init_data
min_smt_sample_dist = sut.min_smt_sample_dist
ci_grid_eps = sut.ci_grid_eps
pi_grid_eps = sut.pi_grid_eps
#num_sim_samples = sut.num_sim_samples
#METHOD = sut.METHOD
#symbolic_analyzer = sut.symbolic_analyzer
#plot = sut.plot
#MODE = sut.MODE
#opts = Options(plot, MODE, num_sim_samples, METHOD, symbolic_analyzer)
except AttributeError as e:
raise MissingSystemDefError(e)
# ROI is not mandatory and defaults to xi \in (-inf, inf)
try:
ROI = cns.IntervalCons(*sut.ROI)
assert (ROI.dim == num_dims.x)
except AttributeError:
ROI = cns.top2ic(num_dims.x)
sys = System(sys_name, controller_path, num_dims, plant_config_dict,
delta_t, controller_path_dir_path, controller_object_str,
path, plant_pvt_init_data, min_smt_sample_dist, ci_grid_eps,
pi_grid_eps)
prop = Property(T, init_cons_list, init_cons, final_cons, ci, pi,
initial_discrete_state, initial_controller_state, MAX_ITER,
num_segments, ROI)
print('system loaded...')
return sys, prop
def box(_, x):
ival_cons = cons.IntervalCons(np.min(x, axis=0), np.max(x, axis=0))
return ival_cons.poly()
def get_ival_constraints(self, abs_state):
ival_l = np.array(abs_state.s)
ival_h = np.array(abs_state.s)
return cons.IntervalCons(ival_l, ival_h)
def ival_constraints(cell, eps):
cell_coordinates = np.array(cell) * eps
ival_l = cell_coordinates
ival_h = cell_coordinates + eps
return cons.IntervalCons(ival_l, ival_h)
def parse_without_sanity_check(file_path):
test_des_file = file_path
path = fp.get_abs_base_path(file_path)
test_dir = fp.get_abs_base_path(test_des_file)
SYS.path.append(test_dir)
sut = imp.load_source('test_des', test_des_file)
plant_config_dict = {
'plant_description': sut.plant_description,
'plant_path': sut.plant_path,
'refinement_factor': sut.refinement_factor,
# 'grid_eps': sut.grid_eps,
# 'num_samples': sut.num_samples,
'delta_t': sut.delta_t,
'type': 'string',
}
for k, d in plant_config_dict.iteritems():
plant_config_dict[k] = str(d)
num_dims = NumDims(
si=len(sut.initial_controller_integer_state),
sf=len(sut.initial_controller_float_state),
s=len(sut.initial_controller_integer_state) +
len(sut.initial_controller_float_state),
x=len(sut.initial_set[0]),
u=sut.num_control_inputs,
ci=len(sut.ci[0]),
pi=0,
d=len(sut.initial_discrete_state),
pvt=0,
)
if num_dims.ci == 0:
ci = None
else:
ci = cns.IntervalCons(np.array(sut.ci[0]), np.array(sut.ci[1]))
if num_dims.pi == 0:
pi = None
else:
pi = cns.IntervalCons(np.array(sut.pi[0]), np.array(sut.pi[1]))
# TODO: fix the list hack, once the controller ifc matures
init_cons = cns.IntervalCons(np.array(sut.initial_set[0]),
np.array(sut.initial_set[1]))
init_cons_list = [init_cons]
final_cons = cns.IntervalCons(np.array(sut.error_set[0]),
np.array(sut.error_set[1]))
T = sut.T
if sut.controller_path is not None:
controller_object_str = fp.split_filename_ext(sut.controller_path)[0]
controller_path_dir_path = fp.construct_path(
sut.controller_path_dir_path, path)
else:
controller_object_str = None
controller_path_dir_path = None
delta_t = sut.delta_t
#try: # enforce it for now!
#except:
# controller_path_dir_path = None
initial_discrete_state = sut.initial_discrete_state
initial_controller_state = sut.initial_controller_integer_state \
+ sut.initial_controller_float_state
MAX_ITER = sut.MAX_ITER
#try: # enforce it for now!
#except:
# None
num_segments = int(np.ceil(T / delta_t))
controller_path = sut.controller_path
plant_pvt_init_data = sut.plant_pvt_init_data
sys = System(controller_path, num_dims, plant_config_dict, delta_t,
controller_path_dir_path, controller_object_str, path,
plant_pvt_init_data)
prop = Property(T, init_cons_list, init_cons, final_cons, ci, pi,
initial_discrete_state, initial_controller_state, MAX_ITER,
num_segments)
#num_sim_samples = sut.num_sim_samples
#METHOD = sut.METHOD
#symbolic_analyzer = sut.symbolic_analyzer
#plot = sut.plot
#MODE = sut.MODE
#opts = Options(plot, MODE, num_sim_samples, METHOD, symbolic_analyzer)
return sys, prop
def overapprox_x0(num_dims, prop, pwa_trace, solver=gopts.opt_engine):
A_ub, b_ub = pwatrace2lincons(pwa_trace, num_dims, prop)
num_opt_vars = A_ub.shape[1]
nvars = num_dims.x + num_dims.pi
#directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
I = np.eye(nvars)
directions = np.vstack((I, -I))
left_over_vars = num_opt_vars - nvars
directions_ext = np.pad(directions, [(0, 0), (0, left_over_vars)],
'constant')
# LP structure: A_ub [x x'] <= b_ub
x_arr = np.array(sym.symbols(['x{}'.format(i) for i in range(nvars)]))
A_ub, b_ub = truncate(A_ub, b_ub)
res = solve_mult_lp(lpfun(solver), directions_ext, A_ub, b_ub)
l = len(res)
assert (l % 2 == 0)
#min_directions, max_directions = np.split(directions, l/2, axis=1)
min_res, max_res = res[:l // 2], res[l // 2:]
ranges = []
for di, rmin, rmax in zip(directions, min_res, max_res):
if (rmin.success and rmax.success):
print('{} \in [{}, {}]'.format(np.dot(di, x_arr), rmin.fun,
-rmax.fun))
ranges.append([rmin.fun, -rmax.fun])
else:
if settings.debug:
print('LP failed')
print('rmin status:', rmin.status)
print('rmax status:', rmax.status)
return None
#raise e
# For python2/3 compatibility
# try:
# input = raw_input
# except NameError:
# pass
# prompt = input('load the prompt? (y/Y)')
# if prompt.lower() == 'y':
# import IPython
# IPython.embed()
#ranges = [[0.00416187, 0.00416187],[3.47047152,3.47047152],[9.98626028,9.98626028],[4.98715449,4.98715449]]
r = np.asarray(ranges)
# due to numerical errors, the interval can be malformed
try:
ret_val = cons.IntervalCons(r[:, 0], r[:, 1])
except:
#from IPython import embed
err.warn('linprog fp failure: Malformed Interval! Please fix.')
#embed()
return None
return ret_val