Python upcast示例

示例#1

文件： op.py 项目： howthebodyworks/research_public

def grad(self, inp, grads):
    """
    
    """
    x, = inp
    gz, = grads
    cst = numpy.asarray(-2. / numpy.sqrt(numpy.pi),
        dtype=upcast(x.type.dtype, gz.type.dtype))
    return gz * (cst + 2. * x * exp(-x * x) * erfcx(x)),

示例#2

文件： basic_scipy.py 项目： repos-python/Theano

 def grad(self, inp, grads):
     x, = inp
     gz, = grads
     if x.type in complex_types:
         raise NotImplementedError()
     elif x.type in float_types:
         cst = numpy.asarray(numpy.sqrt(numpy.pi) / 2.0, dtype=upcast(x.type.dtype, gz.type.dtype))
         return (gz * cst * exp(erfinv(x) ** 2),)
     else:
         return (None,)

示例#3

文件： basic_scipy.py 项目： HaniAlmousli/Theano

 def grad(self, inp, grads):
     x, = inp
     gz, = grads
     if x.type in complex_types:
         raise NotImplementedError()
     elif x.type in float_types:
         cst = numpy.asarray(2. / numpy.sqrt(numpy.pi),dtype=upcast(x.type.dtype,gz.type.dtype))
         return - gz * cst * exp(-x*x),
     else:
         return None,

示例#4

文件： basic_scipy.py 项目： amanrajdce/Theano

    def grad(self, inp, grads):
        x, = inp
        gz, = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if self(x).type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = numpy.asarray(2.0 / numpy.sqrt(numpy.pi), dtype=upcast(x.type.dtype, gz.type.dtype))
        return (-gz * cst * exp(-x * x),)

示例#5

文件： basic_scipy.py 项目： yubow/Theano

    def grad(self, inp, grads):
        x, = inp
        gz, = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if self(x).type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = numpy.asarray(2. / numpy.sqrt(numpy.pi),
                            dtype=upcast(x.type.dtype, gz.type.dtype))
        return gz * cst * exp(-x * x),

示例#6

    def L_op(self, inputs, outputs, grads):
        x, = inputs
        gz, = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if outputs[0].type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = np.asarray(2. / np.sqrt(np.pi),
                         dtype=upcast(x.type.dtype, gz.type.dtype))
        return -gz * cst * exp(-x * x),

示例#7

文件： basic_scipy.py 项目： Thrandis/Theano

    def L_op(self, inputs, outputs, grads):
        x, = inputs
        gz, = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if outputs[0].type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = np.asarray(2. / np.sqrt(np.pi),
                         dtype=upcast(x.type.dtype, gz.type.dtype))
        return - gz * cst * exp(-x * x),

示例#8

    def L_op(self, inputs, outputs, grads):
        (x, ) = inputs
        (gz, ) = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if outputs[0].type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = np.asarray(np.sqrt(np.pi) / 2.0,
                         dtype=upcast(x.type.dtype, gz.type.dtype))
        return (-gz * cst * exp(erfcinv(x)**2), )

示例#9

文件： basic_scipy.py 项目： wuhuizhe/Theano

    def L_op(self, inputs, outputs, grads):
        x, = inputs
        gz, = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if outputs[0].type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = numpy.asarray(2. / numpy.sqrt(numpy.pi),
                            dtype=upcast(x.type.dtype, gz.type.dtype))
        return gz * (-cst + (2. * x) * erfcx(x)),

示例#10

文件： basic_scipy.py 项目： Faruk-Ahmed/Theano

    def L_op(self, inputs, outputs, grads):
        x, = inputs
        gz, = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if outputs[0].type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=theano.config.floatX)]
            else:
                return [x.zeros_like()]

        cst = numpy.asarray(numpy.sqrt(numpy.pi) / 2.,
                            dtype=upcast(x.type.dtype, gz.type.dtype))
        return gz * cst * exp(erfinv(x) ** 2),

示例#11

    def L_op(self, inputs, outputs, grads):
        (x, ) = inputs
        (gz, ) = grads
        if x.type in complex_types:
            raise NotImplementedError()
        if outputs[0].type in discrete_types:
            if x.type in discrete_types:
                return [x.zeros_like(dtype=config.floatX)]
            else:
                return [x.zeros_like()]

        cst = np.asarray(2.0 / np.sqrt(np.pi),
                         dtype=upcast(x.type.dtype, gz.type.dtype))
        return (gz * (-cst + (2.0 * x) * erfcx(x)), )

示例#12

文件： test_inplace.py 项目： rpgoldman/Theano-PyMC

    grad_rtol=div_grad_rtol,
    inplace=True,
)

TestInvInplaceBroadcast = makeBroadcastTester(
    op=inv_inplace,
    expected=lambda x: _numpy_true_div(np.int8(1), x),
    good=_good_inv_inplace,
    bad_runtime=_bad_runtime_inv,
    grad_rtol=div_grad_rtol,
    inplace=True,
)

TestModInplaceBroadcast = makeBroadcastTester(
    op=mod_inplace,
    expected=lambda x, y: np.asarray(x % y, dtype=upcast(x.dtype, y.dtype)),
    good=copymod(_good_broadcast_div_mod_normal_float_inplace,
                 ["complex1", "complex2"]),
    grad_eps=1e-5,
    inplace=True,
)

TestPowInplaceBroadcast = makeBroadcastTester(
    op=pow_inplace,
    expected=lambda x, y: x**y,
    good=_good_broadcast_pow_normal_float_pow,
    inplace=True,
    mode=ignore_isfinite_mode,
)

TestNegInplaceBroadcast = makeBroadcastTester(