def _simple_bin_op(self, i, op): if isinstance(i, H2OVec): return H2OVec(self._name, Expr(op, self._len_check(i), i)) if isinstance(i, (int, float)): return H2OVec(self._name, Expr(op, self, Expr(i))) if isinstance(i, Expr): return H2OVec(self._name, Expr(op, self, i)) raise NotImplementedError
def test_expr_num_check(self): f, fder, fhess = fs_multi[0] x = xs_multi[0] e = Expr(f) with self.assertRaises(AssertionError): e.grad(x, num_check=True) with self.assertRaises(AssertionError): e.hess(x, num_check=True) # wrong fder and fhess fder = lambda x: np.array([[2 * x[0, 0] + 1, 2 * x[1, 0] + 1]]) fhess = lambda x: 3 * np.eye(2) e = Expr(f, fder, fhess) with self.assertRaises(Exception) as cm: e.grad(x, num_check=True) self.assertTrue("Numerical and analytical gradients aren't close"\ in cm.exception.message) with self.assertRaises(Exception) as cm: e.hess(x, num_check=True) self.assertTrue("Numerical and analytical hessians aren't close"\ in cm.exception.message) try: e.grad(x, num_check=True, atol=1.) e.hess(x, num_check=True, atol=1.) except Exception: self.fail("gradient and hessian calls should not raise exception.")
def __getitem__(self, i): if isinstance(i, int): return self._vecs[i] if isinstance(i, str): return self._find(i) # Slice; return a Frame not a Vec if isinstance(i, slice): return H2OFrame(vecs=self._vecs[i]) # Row selection from a boolean Vec if isinstance(i, H2OVec): self._len_check(i) return H2OFrame(vecs=[x.row_select(i) for x in self._vecs]) # have a list/tuple of numbers or strings if isinstance(i, list) or (isinstance(i, tuple) and len(i) != 2): vecs = [] for it in i: if isinstance(it, int): vecs.append(self._vecs[it]) elif isinstance(it, str): vecs.append(self._find(it)) else: raise NotImplementedError return H2OFrame(vecs=vecs) # multi-dimensional slicing via 2-tuple if isinstance(i, tuple): j = h2o.frame(self.send_frame()) fr = j['frames'][0] veckeys = [str(v['name']) for v in fr['vec_keys']] left = Expr(veckeys) rite = Expr((i[0], i[1])) return Expr("[", left, rite, length=2) raise NotImplementedError("Slicing by unknown type: "+str(type(i)))
def __add__(self, i): """ Basic binary addition. Supports H2OVec + H2OVec and H2OVec + int :param i: A Vec or a float :return: A new H2OVec. """ # H2OVec + H2OVec if isinstance(i, H2OVec): # can only add two vectors of the same length if len(i) != len(self): raise ValueError("len(self)=" + len(self) + " cannot be broadcast across len(i)=" + len(i)) # lazy new H2OVec return H2OVec(self.name(), Expr("+", self, i)) # H2OVec + number if isinstance(i, (int, float)): if i == 0: return self # lazy new H2OVec return H2OVec(self.name(), Expr("+", self, Expr(i))) raise NotImplementedError
def concat(left, right): left = Expr(left) right = Expr(right) if left.is_number() and right.is_number() and left() > 0 and right() >= 0: return int(str(left) + str(right)) else: raise Exception
def max(self): """ :return: The maximum value of all frame entries """ if self._vecs is None or self._vecs == []: raise ValueError("Frame Removed") return Expr("max", Expr("cbind",Expr(self._vecs)))
def __setitem__(self, b, c): """ Update-in-place of a Vec. This interface currently only supports whole vector replacement. If `c` has length 1, then it's assumed that `c` represents a constant vector of its current value. :param b: An H2OVec for selecting rows to update in-place. :param c: The "new" values that will write over the values stipulated by `b`. :return: void """ if c and len(c) != 1 and len(c) != len(self): raise ValueError("len(self)=" + len(self) + " cannot be broadcast across len(c)=" + len(c)) # row-wise assignment if isinstance(b, H2OVec): # whole vec replacement if len(b) != len(self): raise ValueError("len(self)=" + len(self) + " cannot be broadcast across len(b)=" + len(b)) # lazy update in-place of the whole vec self._expr = Expr("=", Expr("[", self._expr, b), c) else: raise NotImplementedError("Only vector replacement is currently supported.")
def sum(self): """ :return: The sum of all frame entries """ if self._vecs is None or self._vecs == []: raise ValueError("Frame Removed") return Expr("sum", Expr("cbind",Expr(self._vecs)))
def _simple_frames_bin_op(self, data, op): if len(self) == 0: return self if isinstance(data, H2OFrame) : return Expr(op, Expr(self.send_frame(), length=self.nrow()), Expr(data.send_frame(), length=data.nrow())) elif isinstance(data, H2OVec) : return Expr(op, Expr(self.send_frame(), length=self.nrow()), Expr(H2OFrame(vecs=[data]).send_frame(), length=len(data))) elif isinstance(data, Expr) : return Expr(op, Expr(self.send_frame(), length=self.nrow()), data) elif isinstance(data, (int, float)): return Expr(op, Expr(self.send_frame(), length=self.nrow()), Expr(data)) elif isinstance(data, str) : return Expr(op, Expr(self.send_frame(), length=self.nrow()), Expr(None, data)) else: raise NotImplementedError
def quantile(self, prob=None): """ :return: A lazy Expr representing the quantiles of this H2OVec. """ if not prob: prob = [0.01, 0.1, 0.25, 0.333, 0.5, 0.667, 0.75, 0.9, 0.99] return H2OVec(self._name, Expr("quantile", self, Expr(prob), length=len(prob)))
def runif(self, seed=None): """ :param seed: A random seed. If None, then one will be generated. :return: A new H2OVec filled with doubles sampled uniformly from [0,1). """ if not seed: import random seed = random.randint(123456789, 999999999) # generate a seed return H2OVec("", Expr("h2o.runif", self._expr, Expr(seed)))
def __getitem__(self, i): """ Basic index/sliced lookup :param i: An Expr or an H2OVec :return: A new Expr object corresponding to the input query """ if isinstance(i, H2OVec): return self.row_select(i) e = Expr(i) return Expr("[", self, e, length=len(e))
def unify(expr1, expr2): symbol1 = expr1.symbol symbol2 = expr2.symbol # 如果expr1, expr2是常元或者空表 if ((expr1.name == 'null' and len(symbol1) == 1 and symbol1[0].lower() == symbol1[0]) or (expr1.name == 'null' and \ len(symbol1) == 0)) and ((expr2.name == 'null' and len(symbol2) == 1 and symbol2[0].lower() == symbol2[0]) or \ (expr2.name == 'null' and len(symbol2) == 0)): if expr1.equal(expr2): return '' else: return 'Fail' # 如果expr11是一个变元 if expr1.name == 'null' and len( symbol1) == 1 and symbol1[0].lower() != symbol1[0]: if symbol1[0] in symbol2: return 'Fail' else: return '%s/%s' % (symbol2[0], symbol1[0]) # 如果expr2是一个变元 elif expr2.name == 'null' and len( symbol2) == 1 and symbol2[0].lower() != symbol2[0]: if symbol2[0] in symbol1: return 'Fail' else: return '%s/%s' % (symbol1[0], symbol2[0]) # 其他情况 else: he1 = Expr(1, 'null', [expr1.symbol[0]]) he2 = Expr(1, 'null', [expr2.symbol[0]]) subs1 = unify(he1, he2) if subs1 == 'Fail': return 'Fail' new_expr1 = copy.deepcopy(expr1) new_expr2 = copy.deepcopy(expr2) del new_expr1.symbol[0] del new_expr2.symbol[0] if len(new_expr1.symbol) == 0: new_expr1.name = 'null' new_expr1.sign = 1 if len(new_expr2.symbol) == 0: new_expr2.name = 'null' new_expr2.sign = 1 apply(subs1, new_expr1) apply(subs1, new_expr2) subs2 = unify(new_expr1, new_expr2) if subs2 == 'Fail': return 'Fail' else: if subs2 == '': return subs1 else: return subs1 + ' ' + subs2
def _simple_un_math_op(op, data): """ Element-wise math operations on H2OFrame, H2OVec, and Expr objects. :param op: the math operation :param data: the H2OFrame, H2OVec, or Expr object to operate on. :return: Expr'd data """ if isinstance(data, H2OFrame): return Expr(op, Expr(data.send_frame(), length=data.nrow())) elif isinstance(data, H2OVec) : return Expr(op, data, length=len(data)) elif isinstance(data, Expr) : return Expr(op, data) else: raise ValueError, op + " only operates on H2OFrame, H2OVec, or Expr objects"
def __ge__(self, i): # Vec >= Vec if isinstance(i, H2OVec): if len(i) != len(self): raise ValueError("len(self)=" + len(self) + " cannot be broadcast across len(i)=" + len(i)) return H2OVec(self.name(), Expr(">=", self, i)) # Vec >= number elif isinstance(i, (int, float)): return H2OVec(self.name(), Expr(">=", self, Expr(i))) else: raise NotImplementedError
def __init__(self, pc=None, expression=None, env=None): self.succ_inst = [] self.pred_inst = [] self.category = None self.jump = None self.isLikely = False self.live = Live() self.son = [] if pc: add_edge(pc, self) self.expression = Expr(expression) if expression else Expr("") self.env = env self.line = None self.node_id = Instruction.instruction_count Instruction.instruction_count += 1
def isLikely(_init, _pred, _new): # 判断循环的init,pred,new是否可能可以并行 init = Expr(_init) init.parse() pred = Expr(_pred) pred.parse() new = Expr(_new) new.parse() if len(init.Array_Mdf) == 0 and len(init.Var_Mdf) == 1: if len(new.Var_Rdc) == 1 and ( (new.Var_Rdc[0][1] == "++" or new.Var_Rdc[0][1] == "--") or (len(new.var) == 2 and new.fa[0][0] in "+-" and (new.var[0] is None or new.var[1] is None))): if len(pred.Var_Use) <= 2 and init.Var_Mdf[0] in pred.Var_Use: return True return False
def main(argv): print("===============================================================") print("Notes:") print("1) Only the first line in the input file will be read.") print("2) The line should start and end with \'\"\'.") print("3) '/' in Python and '/' in Python3 are different fot int.") print("===============================================================") """ try: with open(argv[0], 'r') as f: print("Reading file %s..." % argv[0]) pstring = f.readline()[:-1] # if not read from a file TODO formula = stoformula(pstring) print("Formula of the function:") print(formula) except: print("Failed to convert the string to a formula.") """ with open(argv[0], 'r') as f: print("Reading file %s..." % argv[0]) instr = f.read() print("Converting string %s to a formula..." % instr) pstr = PString(instr, "file") plines = pstr.parsestring() expr = Expr(plines) formula = expr.formula() print("Formula for the string:") print(formula) return
def test_leq_expr_convexify(self): for f, fder, _ in fs: e = Expr(f) for x in xs: y = f(x) y_prime = fder(x) leq_e = LEqExpr(e, np.array([1.0])) hinge_e = leq_e.convexify(x) self.assertIsInstance(hinge_e, HingeExpr) aff_e = hinge_e.expr A = aff_e.A b = aff_e.b self.assertTrue(np.allclose(A, fder(x))) self.assertTrue(np.allclose(b, f(x) - A.dot(x) - 1.0)) self.assertTrue( np.allclose(hinge_e.eval(x), np.maximum(y - 1.0, np.zeros(y.shape)))) x2 = x + 1.0 self.assertTrue( np.allclose(hinge_e.eval(x2), np.maximum(A.dot(x2) + b, np.zeros(y.shape))))
def row_select(self, vec): """ Boolean column select lookup :param vec: An H2OVec. :return: A new H2OVec. """ return H2OVec(self.name(), Expr("[", self, vec))
def mktime(year=1970,month=0,day=0,hour=0,minute=0,second=0,msec=0): """ All units are zero-based (including months and days). Missing year is 1970. :return: Returns msec since the Epoch. """ # Some error checking on length xlen = 1 e = None for x in [msec,second,minute,hour,day,month,year]: (l,x) = (1,Expr(x)) if isinstance(x,int) else (len(x),x) if xlen != l: if xlen == 1: xlen = l else: raise ValueError("length of "+str(x)+" not compatible with "+xlen) e = Expr(",", x, e) e2 = Expr("mktime",e,None,xlen) return e2 if xlen==1 else H2OVec("mktime",e2)
def test_expr_eval_grad_hess_multi(self): for f, fder, fhess in fs_multi: e = Expr(f) for x in xs_multi: y = f(x) y_prime = fder(x) y_d_prime = fhess(x) test_expr_val_grad_hess(self, e, x, y, y_prime, y_d_prime)
def test_convexify_deg_2_negative_hessian(self): f = lambda x: -x**2 f_hess = np.array([[-2.0]]) e = Expr(f) quad_e = e.convexify(np.zeros((1, 1)), degree=2) self.assertIsInstance(quad_e, QuadExpr) Q = quad_e.Q self.assertTrue(np.allclose(Q, np.zeros((1, 1))))
def monadic_gen(iterable, monadic, recurse=0): for i in iterable: yield i if recurse > 0: for ope in monadic: if not isinstance(i, Expr): i = Expr(i) for z in monadic_gen([i.apply(ope)], monadic, recurse - 1): yield z
def test_expr_eval_grad_hess_w_fder_and_fhess(self): for f, fder, fhess in fs: e = Expr(f, fder, fhess) for x in xs: y = f(x) y_prime = fder(x) y_d_prime = fhess(x) test_expr_val_grad_hess_with_num_check(self, e, x, y, y_prime, y_d_prime)
def _simple_vec_bin_op( self, i, op): if isinstance(i, H2OFrame ): return i._simple_frames_bin_op(H2OFrame(vecs=[self]),op) if isinstance(i, H2OVec ): return H2OVec(self._name, Expr(op, self._len_check(i), i)) if isinstance(i, (int, float)): return H2OVec(self._name, Expr(op, self, Expr(i))) if isinstance(i, Expr) : return H2OVec(self._name, Expr(op, self, i)) if isinstance(i, str) : return H2OVec(self._name, Expr(op, self, Expr(None,i))) if op == "n" and i is None : return H2OVec(self._name, Expr("is.na", self._expr, None)) raise NotImplementedError
def row_select(self, vec): """ Boolean column select lookup :param vec: An H2OVec. :return: A new H2OVec. """ e = Expr("[", self, vec) j = h2o.frame(e.eager()) e.set_len(j['frames'][0]['rows']) return H2OVec(self._name, e)
def test_convexify_deg_2_multi_dim(self): x0 = np.array([[5.0], [5.0]]) f = lambda x: np.vstack((\ x[0,0]**2 + x[1,0]**2 - 4, \ -((x[0,0]-1)**2 +(x[1,0]**2-1)**2 - 0.25), \ -((x[0,0]+1)**2 +(x[1,0]**2-1)**2 - 0.25), \ -((x[0,0])**2 + 7*(x[1,0]+1-x[0,0]**2/2)**2 - 0.8))) e = Expr(f) aff_e = e.convexify(x0) self.assertTrue(aff_e.A.shape[0] == aff_e.b.shape[0])
def __getitem__(self, i): """ Column selection via integer, string(name) Column selection via slice returns a subset of the H2OFrame :param i: An int, str, slice, H2OVec, or list/tuple :return: An H2OVec, an H2OFrame, or scalar depending on the input slice. """ if self._vecs is None or self._vecs == []: raise ValueError("Frame Removed") if isinstance(i, int): return self._vecs[i] if isinstance(i, str): return self._find(i) # Slice; return a Frame not a Vec if isinstance(i, slice): return H2OFrame(vecs=self._vecs[i]) # Row selection from a boolean Vec if isinstance(i, H2OVec): self._len_check(i) return H2OFrame(vecs=[x.row_select(i) for x in self._vecs]) # have a list/tuple of numbers or strings if isinstance(i, list) or (isinstance(i, tuple) and len(i) != 2): vecs = [] for it in i: if isinstance(it, int): vecs.append(self._vecs[it]) elif isinstance(it, str): vecs.append(self._find(it)) else: raise NotImplementedError return H2OFrame(vecs=vecs) # multi-dimensional slicing via 2-tuple if isinstance(i, tuple): veckeys = [str(v._expr._data) for v in self._vecs] left = Expr(veckeys) rite = Expr((i[0], i[1])) res = Expr("[", left, rite, length=2) if not isinstance(i[0], int) or not isinstance(i[1], int): return res # possible big data # small data (single value) res.eager() if res.is_local(): return res._data j = h2o.frame(res._data) # data is remote return map(list, zip(*[c['data'] for c in j['frames'][0]['columns'][:]]))[0][0] raise NotImplementedError("Slicing by unknown type: "+str(type(i)))
def __setitem__(self, b, c): """ Update-in-place of a Vec. This interface currently only supports whole vector replacement. If `c` has length 1, then it's assumed that `c` represents a constant vector of its current value. :param b: An H2OVec for selecting rows to update in-place. :param c: The "new" values that will write over the values stipulated by `b`. :return: void """ self._len_check(c) # row-wise assignment if isinstance(b, H2OVec): # whole vec replacement self._len_check(b) # lazy update in-place of the whole vec self._expr = Expr("=", Expr("[", self._expr, b), None if c is None else Expr(c)) else: raise NotImplementedError("Only vector replacement is currently supported.")