Python numpy 模块，frompyfunc() 实例源码
我们从Python开源项目中，提取了以下33个代码示例，用于说明如何使用numpy.frompyfunc()。
def set_ufunc(self, scalar_op):
# This is probably a speed up of the implementation
if isinstance(scalar_op, theano.scalar.basic.Add):
self.ufunc = numpy.add
elif isinstance(scalar_op, theano.scalar.basic.Mul):
self.ufunc = numpy.multiply
elif isinstance(scalar_op, theano.scalar.basic.Maximum):
self.ufunc = numpy.maximum
elif isinstance(scalar_op, theano.scalar.basic.Minimum):
self.ufunc = numpy.minimum
elif isinstance(scalar_op, theano.scalar.basic.AND):
self.ufunc = numpy.bitwise_and
elif isinstance(scalar_op, theano.scalar.basic.OR):
self.ufunc = numpy.bitwise_or
elif isinstance(scalar_op, theano.scalar.basic.XOR):
self.ufunc = numpy.bitwise_xor
else:
self.ufunc = numpy.frompyfunc(scalar_op.impl, 2, 1)
def _KeenerMatrix(self, A, C, regularization, func, epsilon):
"""func is a regularization function imposed on every element of matrix.
"""
# Apply Laplace Law
B = A+A.T+2;
A = A+1
A = A/B
# Regularization
if func is not None:
h = np.frompyfunc(func, 1, 1)
A = np.require(h(A), dtype=np.float32)
# divide by contest number
C = C+C.T
c = np.sum(C, axis=1)
if regularization:
A = A/np.expand_dims(c, axis=1)
A[C==0]=0
if epsilon is not None:
A += epsilon*np.ones(A.shape, A.dtype)
return A
def ztnb_pmf(y, mu, alpha):
r = 1.0 / alpha
if y <= 0:
raise Exception('y must be larger than 0.')
p = mu/(mu+r+0.0)
ztnbin_mpmath = lambda y, p, r: mpmath.gamma(y + r)/(mpmath.gamma(y+1)*mpmath.gamma(r))*np.power(1-p, r)*np.power(p, y)/(1-np.power(1-p, r))
ztnbin = np.frompyfunc(ztnbin_mpmath, 3, 1)
return float(ztnbin(y, p, r))
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def _maybe_convert(values, val_kind, encoding):
if _need_convert(val_kind):
conv = _get_converter(val_kind, encoding)
# conv = np.frompyfunc(conv, 1, 1)
values = conv(values)
return values
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def draw_mandelbrot(cx, cy, d):
"""
???(cx, cy)????d????Mandelbrot
"""
x0, x1, y0, y1 = cx-d, cx+d, cy-d, cy+d
y, x = np.ogrid[y0:y1:200j, x0:x1:200j]
c = x + y*1j
start = time.clock()
mandelbrot = np.frompyfunc(iter_point,1,1)(c).astype(np.float)
print("time=",time.clock() - start)
pl.imshow(mandelbrot, cmap=cm.jet, extent=[x0,x1,y0,y1])
#pl.gca().set_axis_off()
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def __setstate__(self, d):
super(Elemwise, self).__setstate__(d)
self.ufunc = None
self.nfunc = None
if getattr(self, 'nfunc_spec', None):
self.nfunc = getattr(numpy, self.nfunc_spec[0])
elif 0 < self.scalar_op.nin < 32:
self.ufunc = numpy.frompyfunc(self.scalar_op.impl,
self.scalar_op.nin,
self.scalar_op.nout)
self._rehash()
def compute_optimal_scales(self):
"""Form a set of scales to use in the wavelet transform.
For non-orthogonal wavelet analysis, one can use an
arbitrary set of scales.
It is convenient to write the scales as fractional powers of
two:
s_j = s_0 * 2 ** (j * dj), j = 0, 1, ..., J
J = (1 / dj) * log2(N * dt / s_0)
s0 - smallest resolvable scale
J - largest scale
choose s0 so that the equivalent Fourier period is 2 * dt.
The choice of dj depends on the width in spectral space of
the wavelet function. For the morlet, dj=0.5 is the largest
that still adequately samples scale. Smaller dj gives finer
scale resolution.
"""
dt = self.dt
# resolution
dj = self.dj
# smallest resolvable scale, chosen so that the equivalent
# fourier period is approximately 2dt
s0 = self.s0
# Largest scale
J = int((1 / dj) * np.log2(self.N * dt / s0))
sj = s0 * 2 ** (dj * np.arange(0, J + 1))
return sj
# TODO: use np.frompyfunc on this
# TODO: can we just replace it with fftfreqs?
def compute_optimal_scales(self):
"""Form a set of scales to use in the wavelet transform.
For non-orthogonal wavelet analysis, one can use an
arbitrary set of scales.
It is convenient to write the scales as fractional powers of
two:
s_j = s_0 * 2 ** (j * dj), j = 0, 1, ..., J
J = (1 / dj) * log2(N * dt / s_0)
s0 - smallest resolvable scale
J - largest scale
choose s0 so that the equivalent Fourier period is 2 * dt.
The choice of dj depends on the width in spectral space of
the wavelet function. For the morlet, dj=0.5 is the largest
that still adequately samples scale. Smaller dj gives finer
scale resolution.
"""
dt = self.dt
# resolution
dj = self.dj
# smallest resolvable scale, chosen so that the equivalent
# fourier period is approximately 2dt
s0 = self.s0
# Largest scale
J = int((1 / dj) * np.log2(self.N * dt / s0))
sj = s0 * 2 ** (dj * np.arange(0, J + 1))
return sj
# TODO: use np.frompyfunc on this
# TODO: can we just replace it with fftfreqs?
def test_frompyfunc_endian(self, level=rlevel):
# Ticket #503
from math import radians
uradians = np.frompyfunc(radians, 1, 1)
big_endian = np.array([83.4, 83.5], dtype='>f8')
little_endian = np.array([83.4, 83.5], dtype='<f8')
assert_almost_equal(uradians(big_endian).astype(float),
uradians(little_endian).astype(float))
def test_frompyfunc_many_args(self):
# gh-5672
def passer(*args):
pass
assert_raises(ValueError, np.frompyfunc, passer, 32, 1)
def test_frompyfunc_nout_0(self):
# gh-2014
def f(x):
x[0], x[-1] = x[-1], x[0]
uf = np.frompyfunc(f, 1, 0)
a = np.array([[1, 2, 3], [4, 5], [6, 7, 8, 9]])
assert_equal(uf(a), ())
assert_array_equal(a, [[3, 2, 1], [5, 4], [9, 7, 8, 6]])
def __init__(self, p = 0.1, r = 10):
nbin_mpmath = lambda k, p, r: mpmath.gamma(k + r)/(mpmath.gamma(k+1)\
*mpmath.gamma(r))*np.power(1-p, r)*np.power(p, k)
self.nbin = np.frompyfunc(nbin_mpmath, 3, 1)
self.p = p
self.r = r
def transform(self,X):
"""
?????: ???0?n-1???????????-1?
X: ?????????DataFrame??Series?
???????????????????DataFrame??Series?
"""
data=X.copy()
if isinstance(data,np.ndarray):
if isinstance(self.fill_na,str):
raise Exception('numpy?????????????')
if not self.return_numeric:
warnings.warn('numpy????????????????????????dataframe?series?')
if not self.return_numeric:
newlabel=self.get_label()
if len(data.shape)==1:
tmp=np.searchsorted(self.cuts,data).astype(int)
result=np.where(np.isnan(data),-1,tmp)
if (not self.return_numeric) and (not isinstance(data,np.ndarray)):
f=np.frompyfunc(lambda xx: newlabel.get(xx,self.fill_na),1,1)
result=f(result)
if isinstance(data,np.ndarray):
result[result==-1]=self.fill_na
else:
result=pd.Series(result)
result.index=data.index
result.index.name=data.index.name
result.name=data.name
result[result==-1]=self.fill_na
data=result.copy()
else:
for feature in self.cuts:
if not isinstance(data,pd.DataFrame):
tmp=np.searchsorted(self.cuts[feature],data[:,feature]).astype(int)
data[:,feature]=np.where(np.isnan(data[:,feature]),self.fill_na,tmp)
else:
tmp=np.searchsorted(self.cuts[feature],data[feature]).astype(int)
data[feature]=np.where(np.isnan(data[feature]),-1,tmp)
if not self.return_numeric:
f=np.frompyfunc(lambda xx: newlabel[feature].get(xx,self.fill_na),1,1)
data[feature]=f(data[feature])
else:
data.loc[data[feature]==-1,feature]=self.fill_na
if self.return_array and isinstance(data,(pd.Series,pd.DataFrame)):
return data.values
else:
return data
def prepare_node(self, node, storage_map, compute_map, impl):
# Postpone the ufunc building to the last minutes
# NumPy ufunc support only up to 31 inputs.
# But our c code support more.
if (len(node.inputs) < 32 and
(self.nfunc is None or
self.scalar_op.nin != len(node.inputs)) and
self.ufunc is None and
impl == 'py'):
ufunc = numpy.frompyfunc(self.scalar_op.impl,
len(node.inputs),
self.scalar_op.nout)
if self.scalar_op.nin > 0:
# We can reuse it for many nodes
self.ufunc = ufunc
else:
node.tag.ufunc = ufunc
# Numpy ufuncs will sometimes perform operations in
# float16, in particular when the input is int8.
# This is not something that we want, and we do not
# do it in the C code, so we specify that the computation
# should be carried out in the returned dtype.
# This is done via the "sig" kwarg of the ufunc, its value
# should be something like "ff->f", where the characters
# represent the dtype of the inputs and outputs.
# NumPy 1.10.1 raise an error when giving the signature
# when the input is complex. So add it only when inputs is int.
out_dtype = node.outputs[0].dtype
if (out_dtype in float_dtypes and
isinstance(self.nfunc, numpy.ufunc) and
node.inputs[0].dtype in discrete_dtypes):
char = numpy.sctype2char(out_dtype)
sig = char * node.nin + '->' + char * node.nout
node.tag.sig = sig
node.tag.fake_node = Apply(
self.scalar_op,
[get_scalar_type(dtype=input.type.dtype).make_variable()
for input in node.inputs],
[get_scalar_type(dtype=output.type.dtype).make_variable()
for output in node.outputs])
self.scalar_op.prepare_node(node.tag.fake_node, None, None, impl)
def perform(self, node, inp, out):
input, = inp
output, = out
axis = self.axis
if axis is None:
axis = list(range(input.ndim))
variable = input
to_reduce = reversed(sorted(axis))
if hasattr(self, 'acc_dtype') and self.acc_dtype is not None:
acc_dtype = self.acc_dtype
else:
acc_dtype = node.outputs[0].type.dtype
if to_reduce:
for dimension in to_reduce:
# If it's a zero-size array, use scalar_op.identity
# if available
if variable.shape[dimension] == 0:
if hasattr(self.scalar_op, 'identity'):
# Compute the shape of the output
v_shape = list(variable.shape)
del v_shape[dimension]
variable = numpy.empty(tuple(v_shape),
dtype=acc_dtype)
variable.fill(self.scalar_op.identity)
else:
raise ValueError((
"Input (%s) has zero-size on axis %s, but "
"self.scalar_op (%s) has no attribute 'identity'"
% (variable, dimension, self.scalar_op)))
else:
# Numpy 1.6 has a bug where you sometimes have to specify
# "dtype='object'" in reduce for it to work, if the ufunc
# was built with "frompyfunc". We need to find out if we
# are in one of these cases (only "object" is supported in
# the output).
if ((self.ufunc.ntypes == 1) and
(self.ufunc.types[0][-1] == 'O')):
variable = self.ufunc.reduce(variable, dimension,
dtype='object')
else:
variable = self.ufunc.reduce(variable, dimension,
dtype=acc_dtype)
variable = numpy.asarray(variable)
if numpy.may_share_memory(variable, input):
# perhaps numpy is clever for reductions of size 1?
# We don't want this.
variable = variable.copy()
output[0] = theano._asarray(variable,
dtype=node.outputs[0].type.dtype)
else:
# Force a copy
output[0] = numpy.array(variable, copy=True,
dtype=node.outputs[0].type.dtype)