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.")
