def bounds(self): """Default bounds method. This is guaranteed to work, and should be fast enough with small number of shapes. Subclasses with large numbers of shapes may see performance benefits from overriding this method. """ if self._bounds is None: left_edge = Min(shape.bounds.left_edge for shape in self.shapes) right_edge = Max(shape.bounds.right_edge for shape in self.shapes) top_edge = Min(shape.bounds.top_edge for shape in self.shapes) bottom_edge = Max(shape.bounds.bottom_edge for shape in self.shapes) self._bounds = Bounds(left_edge, right_edge, top_edge, bottom_edge) return self._bounds
def feed_data(self, X, Y): formula = [] for x, y in zip(X, Y): x_formula = [] for i, (weight, bias) in self.net_formula.items(): if i == 0: x_hidden = [] for r, w_r in enumerate(weight): tmp = Plus([Plus(Times(w, Real(float(x[c]))), bias[r]) for c, w in enumerate(w_r)]) if self.activation == 'relu': x_hidden.append(Max(tmp, Real(0))) else: x_hidden.append(tmp) """node_output = [] for c, w in enumerate(w_r): var = Plus(Times(w, Real(float(x[c]))), bias[r]) exp_3 = Pow(var, Real(3)) #exp_5 = Pow(var, Real(5)) sen_2 = Times(Real(0.25), var) sen_3 = Times(Real(0.02), exp_3) #sen_4 = Times(Real(0.002), exp_5) node_output.append(Plus(Real(0.5), sen_2, sen_3))#, sen_4)) matrix_addition = Plus(node_output[i] for i in range(len(node_output))) x_hidden.append(matrix_addition)""" x = x_hidden else: x_hidden = [] for r, w_r in enumerate(weight): tmp = Plus([Plus(Times(w, x[c]), bias[r]) for c, w in enumerate(w_r)]) if self.activation == 'relu' and i < len(self.net_formula) - 1: x_hidden.append(Max(tmp, Real(0))) else: x_hidden.append(tmp) """node_output = [] for c, w in enumerate(w_r): var = Plus(Times(w, x[c]), bias[r]) exp_3 = Pow(var, Real(3)) #exp_5 = Pow(var, Real(5)) sen_2 = Times(Real(0.25), var) sen_3 = Times(Real(0.02), exp_3) #sen_4 = Times(Real(0.002), exp_5) node_output.append(Plus(Real(0.5), sen_2, sen_3)) #, sen_4)) matrix_addition = Plus(node_output[i] for i in range(len(node_output))) x_hidden.append(matrix_addition)""" x = x_hidden ## Add activation function if np.argmax(y) == 0: x_formula.append(GE(x[0], x[1])) else: x_formula.append(GE(x[1], x[0])) return And(x_formula)
def convert(self, abstract=False): for i in range(self.nnet.inputSize): x = Symbol("x%d" % i, REAL) self.input_vars.append(x) for i in range(self.nnet.outputSize): y = Symbol("y%d" % i, REAL) self.output_vars.append(y) # for i,v in enumerate(self.input_vars): # # normalized # m = self.nnet.mins[i] # l = GE(self.input_vars[i], # Real((m - self.nnet.means[i])/self.nnet.ranges[i])) # self.formulae.append(l) # # normalized # m = self.nnet.maxes[i] # l = LE(self.input_vars[i], # Real((m - self.nnet.means[i])/self.nnet.ranges[i])) # self.formulae.append(l) prev_layer_result = self.input_vars.copy() layer_result = [] zero = Real(0) self.relus_level.append(set()) for l in range(self.nnet.numLayers - 1): self.relus_level.append(set()) for ls in range(self.nnet.layerSizes[l + 1]): r = self.dot(self.nnet.weights[l][ls], prev_layer_result) r = Plus(r, Real(float(self.nnet.biases[l][ls]))) relu_in = FreshSymbol(REAL) self.formulae.append(Equals(relu_in, r)) if abstract: relu_out = FreshSymbol(REAL) r = relu_out self.relus.append((relu_out, relu_in)) self.relus_level[l + 1].add((relu_out, relu_in)) else: r = Max(relu_in, zero) layer_result.append(r) prev_layer_result = layer_result.copy() layer_result.clear() for i, y in enumerate(self.output_vars): o = self.dot(self.nnet.weights[-1][i], prev_layer_result) o = Plus(o, Real(float(self.nnet.biases[-1][i]))) # # undo normalization # o = Times(o, Real(self.nnet.ranges[-1])) # o = Plus(o, Real(self.nnet.means[-1])) self.formulae.append(Equals(y, o)) self.parse_violation(self.violation_path)
def bounds(self): xs = (self.pt1.x, self.pt2.x) ys = (self.pt1.y, self.pt2.y) left_edge, right_edge = Min(*xs), Max(*xs) top_edge, bottom_edge = Min(*ys), Max(*ys) return Bounds(left_edge, right_edge, top_edge, bottom_edge)
def init(self): self.solver.add_assertion(And(self.formulae)) self.sat_checker.add_assertion(And(self.formulae)) for r1, r2 in self.relus: self.sat_checker.add_assertion(Equals(r1, Max(r2, Real(0))))
def processor(config_file_name): var_str = [] coefficients = [] constrnt_mins = [] constrnt_maxes = [] constraint_terms = [] num_vars = [] num_expr = [] terms = [] eqn_mins = [] eqn_maxes = [] readfile(config_file_name, var_str, coefficients, constrnt_mins, constrnt_maxes, constraint_terms, num_vars, num_expr, eqn_mins, eqn_maxes) nvars = num_vars[0] nexpr = num_expr[0] symbols = [Symbol(X, REAL) for X in sorted(var_str)] symbols.append(Symbol("c", REAL)) for x in itertools.combinations_with_replacement(symbols, 2): terms.append(x) for i in range(0, len(terms), 1): terms[i] = list(terms[i]) for i in range(0, len(terms), 1): if (Symbol("c", REAL) in terms[i]): terms[i].remove(Symbol("c", REAL)) # [('x1', 'x1'), ('x1', 'x2'), ('x1', 'c'), ('x2', 'x2'), ('x2', 'c'), ('c', 'c')] sorted(terms, key=lambda elem: elem[0]) #print(terms) variables = set(symbols) d = [] j = 0 for CONSTRAINT in constraint_terms: C = [] for i in range(0, len(CONSTRAINT), 1): if (symbols[i] == Symbol("c", REAL)): C.append(Real(CONSTRAINT[i])) else: C.append(Times(Real(CONSTRAINT[i]), symbols[i])) C = Plus(C) d.append( And(GE(C, Real(constrnt_mins[j])), LT(C, Real(constrnt_maxes[j])))) j = j + 1 domains = And(d) eqns = [] i = 0 for expr in coefficients: cur = [] j = 0 for term in expr: if (len(terms[j]) == 2): cur.append(Times(Real(float(term)), Times(terms[j]))) elif (Symbol("c", REAL) in terms[j]): cur.append(Real(float(term))) else: cur.append(Times(Real(float(term)), terms[j][0])) j = j + 1 cur = Plus(cur) eqns.append(cur) i = i + 1 formulas = [] models = [] satisfiable = bool(True) i = 0 for eqn in eqns: p0 = And(domains, GE(Min(eqn), Real(float(eqn_mins[i])))) p1 = And(domains, LT(Max(eqn), Real(float(eqn_maxes[i])))) formulas.append(p0) formulas.append(p1) models.append(get_model(p0)) models.append(get_model(p1)) i = i + 1 out_str = "" i = 0 j = 0 postfix = ["min satisfiability", "max satisfiability"] pat = re.compile(r'\d+/\d+') for model in models: print("\tModel {} {}: ".format(str(i), postfix[j % 2])) #formula_str = model.print#str(formulas[i].serialize()) cur_str = pysmt.shortcuts.simplify(formulas[j]).serialize().replace( "&", "\n\t\t\t&") cur_str = re.sub( pat, lambda match: "{0}".format( str( float(str(match.group()).split("/")[0]) / float( str(match.group()).split("/")[1]))), cur_str) if model: print("\t\tSerialization of the formula:") print("\t\t\t" + cur_str) #temp_strs = formula_str.split("&") #for k in range(1,len(temp_strs)): # temp_strs[k] = "& " + temp_strs[k] #formula_strs = [] #for s in temp_strs: # t = s.split(" + ") # ts = [] # ts.append(t[0]) # for k in range(1,len(t)): # ts.append(" + " + t[k]) # new_t = [a+b+c+d for a,b,c,d in zip(*[iter(ts)]*4)] # final = "" # for k in range(len(ts) - (len(ts) % 4), len(ts),1): # final = final + ts[k] # new_t.append(final) # formula_strs.append(new_t) #for s in formula_strs: # print("\t\t\t%s" % s) print("\t\tSolution: ") model_str = str(model) model_str = model_str.replace("\n", "\n\t\t\t") print("\t\t\t%s" % model_str) else: print("\t\tSerialization of the formula: ") print("\t\t\t%s" % cur_str) print("\t\tNo solution found") satisfiable = False if j % 2 == 1: i = i + 1 j = j + 1 print("\tResult: ") if (satisfiable): print("\t\tThe problem is satisfiable using the solutions given.") else: print("\t\tThe problem is not satisfiable") return satisfiable
def main(): # Given variables ================================================= I = int(input()) J = int(input()) K = int(input()) T_MAX = int(input()) array_1D = Symbol("1D", ArrayType(INT, INT)) array_2D = Symbol("2D", ArrayType(INT, ArrayType(INT, INT))) # T[j][k] # Earliest start execution time of service k on server j ''' T = Symbol("T", ArrayType(INT, ArrayType(INT, INT))) for j in range(0, J): T_row = array_1D k = 0 for val in [int(x) for x in input().split()]: # print(symbol_name("T", j, k), " -> ", str(val)) T_row = T_row.Store(Int(k), Int(val)) k = k + 1 T = T.Store(Int(j), T_row) ''' T = Symbol("T", ArrayType(INT, ArrayType(INT, ArrayType(INT, INT)))) for i in range(0, I): T_mat = array_2D for j in range(0, J): T_mat_row = array_1D k = 0 for val in [int(x) for x in input().split()]: # print(symbol_name("T", j, k), " -> ", str(val)) T_mat_row = T_mat_row.Store(Int(k), Int(val)) k = k + 1 T_mat = T_mat.Store(Int(j), T_mat_row) T = T.Store(Int(i), T_mat) # C[j][k] # The computation time of service k on server j C = Symbol("C", ArrayType(INT, ArrayType(INT, INT))) for j in range(0, J): C_row = array_1D k = 0 for val in [int(x) for x in input().split()]: # print(symbol_name("C", j, k), " -> ", str(val)) C_row = C_row.Store(Int(k), Int(val)) k = k + 1 C = C.Store(Int(j), C_row) # Tv[j][j'][k] # the transmission time (delivery) of service k from server j to server j' Tv = Symbol("Tv", ArrayType(INT, ArrayType(INT, ArrayType(INT, INT)))) for j in range(0, J): Tv_mat = array_2D for jj in range(0, J): Tv_mat_row = array_1D k = 0 for val in [int(x) for x in input().split()]: # print(symbol_name("Tv", j, jj, k), " -> ", str(val)) Tv_mat_row = Tv_mat_row.Store(Int(k), Int(val)) k = k + 1 Tv_mat = Tv_mat.Store(Int(jj), Tv_mat_row) Tv = Tv.Store(Int(j), Tv_mat) # D[i][k] # Vehicle i's reception deadline for service k # valid[i][k] == -1 iff vehicle i doesn't demand service k D = Symbol("D", ArrayType(INT, ArrayType(INT, INT))) valid = [] for i in range(0, I): D_row = array_1D k = 0 valid.append([]) for val in [int(x) for x in input().split()]: # print(symbol_name("D", i, k), " -> ", str(val)) D_row = D_row.Store(Int(k), Int(val)) k = k + 1 if (val == -1): valid[-1].append(False) else: valid[-1].append(True) D = D.Store(Int(i), D_row) # F[i][k] # The required freshness of vehicle i for service k F = Symbol("F", ArrayType(INT, ArrayType(INT, INT))) for i in range(0, I): F_row = array_1D k = 0 for val in [int(x) for x in input().split()]: # print(symbol_name("F", i, k), " -> ", str(val)) F_row = F_row.Store(Int(k), Int(val)) k = k + 1 F = F.Store(Int(i), F_row) # R[i][j][t] # if vehicle i is in the communication of server j at time t ''' R = Symbol("R", ArrayType(INT, ArrayType(INT, ArrayType(INT, INT)))) for i in range(0, I): R_mat = array_2D for j in range(0, J): R_mat_row = array_1D t = 0 for val in [int(x) for x in input().split()]: # print(symbol_name("R", i, j, t), " -> ", str(val)) R_mat_row = R_mat_row.Store(Int(t), Int(val)) t = t + 1 R_mat = R_mat.Store(Int(j), R_mat_row) R = R.Store(Int(i), R_mat) ''' R = Symbol("R", ArrayType(INT, ArrayType(INT, INT))) for i in range(0, I): R_mat = array_1D R_it = input().split(',') t = 0 for r in R_it: cum_t = int(r.split()[0]) cur_j = int(r.split()[1]) for _ in range(cum_t): R_mat = R_mat.Store(Int(t), Int(cur_j)) t += 1 R = R.Store(Int(i), R_mat) # M[k] # the required memory size (delivery) of service k M = [int(x) for x in input().split()] # M_bar[j] # the memory size of server j M_bar = [int(x) for x in input().split()] start_time = time.time() # Decision variables ================================================= class DV: # Decision variable def __init__(self, i, k): self.i_int = i self.k_int = k self.i = Int(i) self.k = Int(k) self.e = Symbol(symbol_name("e", i, k), INT) self.d = Symbol(symbol_name("d", i, k), INT) self.s = Symbol(symbol_name("s", i, k), INT) self.t = Symbol(symbol_name("t", i, k), INT) DV_set = set() for i in range(0, I): for k in range(0, K): if valid[i][k]: DV_set.add(DV(i, k)) # Constraints ================================================= # Variable domain domain = And( [And(GE(dv.e, Int(0)), LT(dv.e, Int(J))) for dv in DV_set] + [And(GE(dv.d, Int(0)), LT(dv.d, Int(J))) for dv in DV_set] + [And(GE(dv.s, Int(0)), LT(dv.s, Int(T_MAX))) for dv in DV_set] + [And(GE(dv.t, Int(0)), LT(dv.t, Int(T_MAX))) for dv in DV_set]) # Execution constraint eq1 = And([ Or(dv1.s + C.Select(dv1.e).Select(dv1.k) <= dv2.s, dv1.s >= dv2.s + C.Select(dv2.e).Select(dv2.k), And(dv1.k.Equals(dv2.k), dv1.s.Equals(dv2.s))) for (dv1, dv2) in itertools.combinations(DV_set, 2) ]) # Timing constraint #eq2 = And([T.Select(dv.e).Select(dv.k) <= dv.s for dv in DV_set]) eq2 = And( [T.Select(dv.i).Select(dv.e).Select(dv.k) <= dv.s for dv in DV_set]) eq3 = And([ dv.s + C.Select(dv.e).Select(dv.k) + Tv.Select(dv.e).Select(dv.d).Select(dv.k) <= dv.t for dv in DV_set ]) eq4 = And([dv.t <= D.Select(dv.i).Select(dv.k) for dv in DV_set]) eq5 = And([dv.t <= dv.s + F.Select(dv.i).Select(dv.k) for dv in DV_set]) #eq3_1 = And([Tv.Select(dv.e).Select(dv.d).Select(dv.k) >= 0]) # Pinpoint constraint #eq6 = And([R.Select(dv.i).Select(dv.d).Select(dv.t).Equals(Int(1)) for dv in DV_set]) eq6 = And([R.Select(dv.i).Select(dv.t).Equals(dv.d) for dv in DV_set]) # Memory constraint eq7 = And(Bool(True)) memory_sums = [] # for objective function for t in range(0, T_MAX): memory_sums.append(Int(0)) for j in range(0, J): memory_sum = Int(0) # for a single server at time t for dv in DV_set: indicator = Symbol( symbol_name("ind", j, t, dv.i_int, dv.k_int), INT) existence_formula = And( dv.d.Equals(j), t >= dv.s + C.Select(dv.e).Select(dv.k) + Tv.Select(dv.e).Select(dv.d).Select(dv.k), t < dv.t) # print(existence_formula.Iff(indicator.Equals(1))) eq7 = eq7.And(Not(existence_formula).Iff(indicator.Equals(0))) eq7 = eq7.And(existence_formula.Iff(indicator.Equals(1))) memory_sum += M[dv.k_int] * indicator eq7 = eq7.And(memory_sum <= M_bar[j]) memory_sums[-1] += memory_sum # print(memory_sum) # print(eq7) # print(memory_sums[0]) # memory_sums[t] == the sum of memory usage of all server at time t # # Decision version # # Objective constraint # obj = Max(memory_sums) <= 4 # model = get_model(And(domain, eq1, eq2, eq3, eq4, eq5, eq6, eq7, obj)) # print(model) # Optimization version # Minimize the maximum memory used constraints = And(domain, eq1, eq2, eq3, eq4, eq5, eq6, eq7) if (not is_sat(And(constraints, Max(memory_sums) <= sum(M_bar)), solver_name="z3")): print("Unsat") else: if (is_sat(And(constraints, Max(memory_sums) <= 0), solver_name="z3")): print(f"Objective value = 0") #print(get_model(And(constraints, Max(memory_sums) <= 0))) else: l = 1 r = sum(M_bar) + 1 while l < r: # print(f"{l}, {r}") m = int((l + r) / 2) if is_sat(And(constraints, Max(memory_sums) <= m), solver_name="z3"): # print(m) r = m else: l = m + 1 print(f"Objective value = {l}") #print(get_model(And(constraints, Max(memory_sums) <= m))) # print(is_sat(And(domain, eq1, eq2, eq3, eq4, eq5, eq6, eq7, obj))) running_time = time.time() - start_time outfile = open("time.out", "a") outfile.write(f"{running_time}") outfile.write("\n")