def max_pool_2d(x, kernelshape, pad=(0, 0), stride=(1, 1)): devtype = cgt.get_config()["default_device"].devtype kernel_h, kernel_w = kernelshape pad_h, pad_w = pad stride_h, stride_w = stride info = PoolInfo(kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w) if devtype == "gpu": return core.Result(cudnn_ops.CudnnPoolForward(info), [x]) else: return core.Result(MaxPool(info), [x])[0]
def pullback(self, inputs, _output, gout): X, W, b = inputs # pass in an extra first argument to make output shape computation simpler return [ core.Result( CudnnConvBackwardData(self.ph, self.pw, self.sv, self.sh), [X, gout, W]), core.Result( CudnnConvBackwardFilter(self.ph, self.pw, self.sv, self.sh), [W, gout, X]), core.Result( CudnnConvBackwardBias(self.ph, self.pw, self.sv, self.sh), [b, gout]) ]
def max_pool_2d(x, kernelshape, pad=(0, 0), stride=(1, 1)): kernel_h, kernel_w = kernelshape pad_h, pad_w = pad stride_h, stride_w = stride return core.Result( MaxPool(PoolInfo(kernel_h, kernel_w, pad_h, pad_w, stride_h, stride_w)), [x])[0]
def softplus(x): op = core.ElwiseUnary( "softplus", core.UnaryInfo("SoftPlus", _nu_softplus, True, 'f', lambda x, g, gy: gy / (cgt.exp(-x) + 1.0), "(x > 0) ? (x + log(exp(-x) + 1)) : log(1+exp(x))")) return core.Result(op, [x])
def conv2d(x_BKRC, f_LKrc, kernelshape, pad=(0, 0), stride=(1, 1)): devtype = cgt.get_config()["default_device"].devtype L, K, r, c = f_LKrc.shape if devtype == "gpu": b_1K11 = cgt.zeros((1, L, 1, 1), cgt.floatX) return core.Result( cudnn_ops.CudnnConvForward(pad[0], pad[1], stride[0], stride[1]), [x_BKRC, f_LKrc, b_1K11]) else: assert devtype == "cpu" col_BmnZ = im2col(x_BKRC, kernelshape, pad, stride) f_LZ = f_LKrc.reshape([L, K * r * c]) B, m, n, Z = col_BmnZ.shape col_Bmn_Z = col_BmnZ.reshape([B * m * n, Z]) col_Bmn_L = core.Result(core.Mul22(False, True), [col_Bmn_Z, f_LZ]) return col_Bmn_L.reshape([B, m, n, L]).transpose([0, 3, 1, 2])
def conv2d(x_BKRC, f_LKrc, kernelshape, pad=(0, 0), stride=(1, 1)): col_BmnZ = im2col(x_BKRC, kernelshape, pad, stride) L, K, r, c = f_LKrc.shape f_LZ = f_LKrc.reshape([L, K * r * c]) B, m, n, Z = col_BmnZ.shape col_Bmn_Z = col_BmnZ.reshape([B * m * n, Z]) col_Bmn_L = core.Result(core.Mul22(False, True), [col_Bmn_Z, f_LZ]) return col_Bmn_L.reshape([B, m, n, L]).transpose([0, 3, 1, 2])
def pullback(self, inputs, output, goutput): if self.pullback_impl is None: raise core.MethodNotDefined pb_input_types = self.input_types + [self.output_type]*2 pb_output_type = core.TupleType(*self.input_types) pbop = EasyCustomOp(pb_input_types, pb_output_type, forward_impl=self.pullback_impl, pullback_impl=None, shapefun = lambda *args : tuple(cgt.shape(x) for x in inputs) ) return cgt.core.unpack(core.Result(pbop, inputs + [output, goutput]))
def test_multi_output(): for x in (cgt.scalar('x'), cgt.vector('x'), cgt.matrix('x')): for cls in (SinCos, SinCos2): y, z = core.unpack(core.Result(cls(), [x])) xnum = np.ones((3, ) * x.ndim, cgt.floatX) correct = (np.sin(xnum), np.cos(xnum)) yznum = cgt.numeric_eval([y, z], {x: xnum}) np.testing.assert_allclose(yznum, correct) f = cgt.function([x], [y, z]) np.testing.assert_allclose(f(xnum), correct)
def test_scalars(): np.random.seed(0) x = cgt.scalar('x') y = cgt.scalar('y') z = cgt.scalar('z') vars = [x,y,z] #pylint: disable=W0622 vals = nr.rand(len(vars))+1 PROB2RESULT = {} for ((key,_), cls) in it.chain( it.izip(core.UNARY_INFO.items(),it.repeat(core.ElwiseUnary)), it.izip(core.BINARY_INFO.items(),it.repeat(core.ElwiseBinary)) ): if key == "conj": print "skipping conj" continue utils.colorprint(utils.Color.YELLOW, "Testing %s\n"%key) if cls == core.ElwiseUnary: n_in = 1 op = cls(key) else: n_in = 2 op = cls(key, (True,True)) inputvars = vars[0:n_in] inputvals = vals[0:n_in] out = core.Result(op, inputvars) f = cgt.function(inputvars, out) try: grads = cgt.grad(out, inputvars) except core.NonDifferentiable: print "nondiff" continue if DISPLAY: print "Function:" cgt.print_tree(out) print "Gradient original:" cgt.print_tree(grads) print "Gradient simplified:" grads_simple = core.simplify(grads) if DISPLAY: cgt.print_tree(grads_simple) gradf = cgt.function(inputvars, grads) eps = {"single":1e-4,"double":1e-9}[cgt.get_precision()] nugrad = numeric_grad(lambda li: f(*li), inputvals,eps=eps) #pylint: disable=W0640 cgtgrad = gradf(*inputvals) np.testing.assert_almost_equal(nugrad,cgtgrad,decimal={"single":3,"double":6}[cgt.get_precision()]) grad_count = core.count_nodes(grads_simple) PROB2RESULT[key] = {} PROB2RESULT[key]["grad"] = grad_count if DISPLAY: from thirdparty.tabulate import tabulate print tabulate([[key,val["grad"]] for (key,val) in PROB2RESULT.iteritems()],headers=["funcname","gradcount"])
class Im2Col(core.Op): available_impls = ("native_cpu", ) def __init__(self, info): assert info.stride_h > 0 and info.stride_w > 0 self.info = info def get_diff(self, _): return [True] def get_py_impl(self): raise core.MethodNotDefined def pullback(self, (x, ), _y, gy): return [core.Result(Col2Im(self.info), [gy] + cgt.shape(x))]
class MaxPool(core.Op): available_impls = ("native_cpu", ) def __init__(self, info): assert info.stride_h > 0 and info.stride_w > 0 self.info = info def get_diff(self, _): return [True] def get_py_impl(self): raise core.MethodNotDefined def pullback(self, (x, ), y, gy): pool, mask = core.unpack(y) gpool, _gmask = gy return [ core.Result(MaxPoolPullback(self.info), [x, pool, mask, gpool]) ]
def im2col(x, kernelshape, pad, stride): assert stride[0] > 0 and stride[1] > 0 assert kernelshape[0] > 0 and kernelshape[1] > 0 kernelshape, pad, stride = map(tuple, (kernelshape, pad, stride)) return core.Result(Im2Col(Im2ColInfo(*(kernelshape + pad + stride))), [x])
def pullback(self, inputs, output, gout): top, scaling = cgt.core.unpack(output) gtop, _ = gout return [core.Result(CrossChannelLRNBackward(self.info), [inputs[0], top, scaling, gtop])]
def cross_channel_lrn(X, localsize, alpha, beta): assert X.ndim == 4 return core.Result(CrossChannelLRNForward(LRNInfo(localsize,alpha,beta)), [X])[0]
def matmat00a(X, Y): if isinstance(X, np.ndarray): return np.dot(X, Y).sum() else: return sum(core.Result(core.Mul22(False, False), [X, Y]))
def matmat11a(X, Y): if isinstance(X, np.ndarray): return np.dot(X.T, Y.T).sum() else: return sum(core.Result(core.Mul22(True, True), [X, Y]))
def pullback(self, inputs, output, gout): return [ core.Result(CudnnPoolBackward(self.info), [inputs[0], output, gout]) ]