The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def __init__(self, bounds, orig_resolution, tile_width, tile_height, tile_format_url,
zoom_level=0, missing_z=None, image_leaf_shape=None):
self.orig_bounds = bounds
self.orig_resolution = orig_resolution
self.tile_width = tile_width
self.tile_height = tile_height
self.tile_format_url = tile_format_url
self.zoom_level = int(zoom_level)
if missing_z is None:
missing_z = []
self.missing_z = frozenset(missing_z)
if image_leaf_shape is None:
image_leaf_shape = [10, tile_height, tile_width]
scale = np.exp2(np.array([0, self.zoom_level, self.zoom_level])).astype(np.int64)
data_shape = (np.zeros(3), np.divide(bounds, scale).astype(np.int64))
self.image_data = OctreeVolume(image_leaf_shape,
data_shape,
'float32',
populator=self.image_populator)
self.label_data = None Example 2
def perplexity(self):
log_likelihood = 0.
for doc_ix in xrange(self.num_docs):
prob_topic_given_document = np.zeros(self.K)
for i in xrange(self.K):
prob_topic_given_document[i] = (self.ndt[doc_ix][i] + self.alpha) / (
self.nd[doc_ix] + self.K * self.alpha)
for word in self.corpus[doc_ix]:
prob_word_given_topic = np.zeros(self.K)
word_ix = self.word2ix[word]
for j in xrange(self.K):
prob_word_given_topic[j] = (self.ntw[j][word_ix] + self.beta) / (self.nt[j] + self.K * self.alpha)
prob_word = 0.
for j in xrange(self.K):
prob_word += prob_topic_given_document[j] * prob_word_given_topic[j]
log_likelihood += np.log(prob_word)
perplexity = np.exp2(-log_likelihood / self.num_docs)
return perplexity Example 3
def zero_fill(Ix, zff):
"""
Zero-fill interferogram.
Assymetric to prevent zpd from changing index.
Args:
Ix (np.array): 1D array with a single interferogram
zff (int): Zero-filling factor
Returns:
Ix_zff: 1D array of Ix + zero fill
"""
N = Ix.shape[0]
# Calculate next power of two for DFT efficiency
N_2 = int(np.exp2(np.ceil(np.log2(N))))
# fill to N**2 * zff
zero_fill = ((N_2 - N) + (N_2 * (zff)))
Ix_zff = np.hstack((Ix, np.zeros(zero_fill)))
return Ix_zff Example 4
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 5
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 6
def undo_log_transform_if_needed(data_df, prov_code):
"""Undo log transformation if L2X is in prov_code."""
if LOG_TRANSFORM_PROV_CODE_ENTRY in prov_code:
out_df = np.exp2(data_df)
else:
out_df = data_df
return out_df Example 7
def exp2(x):
return x.__class__(numpy.exp2(x)) Example 8
def __init__(self, parent, downsample):
self.scale = np.exp2(downsample).astype(np.int64)
super(DownsampledVolume, self).__init__(
parent,
np.multiply(parent.resolution, self.scale),
image_data=parent.image_data,
label_data=parent.label_data,
mask_data=parent.mask_data) Example 9
def resolution(self):
return self.orig_resolution * np.exp2([0, self.zoom_level, self.zoom_level]) Example 10
def __init__(self, leaf_shape, bounds, dtype, populator=None):
self.leaf_shape = np.asarray(leaf_shape).astype(np.int64)
self.bounds = (np.asarray(bounds[0], dtype=np.int64),
np.asarray(bounds[1], dtype=np.int64))
self.dtype = np.dtype(dtype)
self.populator = populator
ceil_bounds = self.leaf_shape * \
np.exp2(np.ceil(np.log2((self.bounds[1] - self.bounds[0]) /
self.leaf_shape.astype(np.float64)))).astype(np.int64).max()
self.root_node = BranchNode(self, (self.bounds[0], self.bounds[0] + ceil_bounds), clip_bound=self.bounds[1]) Example 11
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 12
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 13
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 14
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 15
def log_perplexity(self, chunk):
"""Return per-word lower bound on log perplexity.
Also logs this and perplexity at INFO level.
"""
vw_data = self._predict(chunk)[1]
corpus_words = sum(cnt for document in chunk for _, cnt in document)
bound = -vw_data['average_loss']
LOG.info("%.3f per-word bound, %.1f perplexity estimate based on a "
"held-out corpus of %i documents with %i words",
bound,
numpy.exp2(-bound),
vw_data['corpus_size'],
corpus_words)
return bound Example 16
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 17
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 18
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 19
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 20
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 21
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 22
def test_numpy_method():
# This type of code is used frequently by PyMC3 users
x = tt.dmatrix('x')
data = np.random.rand(5, 5)
x.tag.test_value = data
for fct in [np.arccos, np.arccosh, np.arcsin, np.arcsinh,
np.arctan, np.arctanh, np.ceil, np.cos, np.cosh, np.deg2rad,
np.exp, np.exp2, np.expm1, np.floor, np.log,
np.log10, np.log1p, np.log2, np.rad2deg,
np.sin, np.sinh, np.sqrt, np.tan, np.tanh, np.trunc]:
y = fct(x)
f = theano.function([x], y)
utt.assert_allclose(np.nan_to_num(f(data)),
np.nan_to_num(fct(data))) Example 23
def impl(self, x):
# If x is an int8 or uint8, numpy.exp2 will compute the result in
# half-precision (float16), where we want float32.
x_dtype = str(getattr(x, 'dtype', ''))
if x_dtype in ('int8', 'uint8'):
return numpy.exp2(x, sig='f')
return numpy.exp2(x) Example 24
def grad(self, inputs, gout):
(x,) = inputs
(gz,) = gout
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()]
return gz * exp2(x) * log(numpy.cast[x.type](2)), Example 25
def c_code(self, node, name, inputs, outputs, sub):
(x,) = inputs
(z,) = outputs
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = exp2(%(x)s);" % locals() Example 26
def test_log1p_compiler_shenanigans(self):
# Check if log1p is behaving on 32 bit intel systems.
assert_(np.isfinite(np.log1p(np.exp2(-53)))) Example 27
def test_exp2_values(self):
x = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
y = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for dt in ['f', 'd', 'g']:
xf = np.array(x, dtype=dt)
yf = np.array(y, dtype=dt)
assert_almost_equal(np.exp2(yf), xf) Example 28
def test_numpy_ufuncs(self):
# test ufuncs of numpy 1.9.2. see:
# http://docs.scipy.org/doc/numpy/reference/ufuncs.html
# some functions are skipped because it may return different result
# for unicode input depending on numpy version
for name, idx in compat.iteritems(self.indices):
for func in [np.exp, np.exp2, np.expm1, np.log, np.log2, np.log10,
np.log1p, np.sqrt, np.sin, np.cos, np.tan, np.arcsin,
np.arccos, np.arctan, np.sinh, np.cosh, np.tanh,
np.arcsinh, np.arccosh, np.arctanh, np.deg2rad,
np.rad2deg]:
if isinstance(idx, pd.tseries.base.DatetimeIndexOpsMixin):
# raise TypeError or ValueError (PeriodIndex)
# PeriodIndex behavior should be changed in future version
with tm.assertRaises(Exception):
func(idx)
elif isinstance(idx, (Float64Index, Int64Index)):
# coerces to float (e.g. np.sin)
result = func(idx)
exp = Index(func(idx.values), name=idx.name)
self.assert_index_equal(result, exp)
self.assertIsInstance(result, pd.Float64Index)
else:
# raise AttributeError or TypeError
if len(idx) == 0:
continue
else:
with tm.assertRaises(Exception):
func(idx)
for func in [np.isfinite, np.isinf, np.isnan, np.signbit]:
if isinstance(idx, pd.tseries.base.DatetimeIndexOpsMixin):
# raise TypeError or ValueError (PeriodIndex)
with tm.assertRaises(Exception):
func(idx)
elif isinstance(idx, (Float64Index, Int64Index)):
# results in bool array
result = func(idx)
exp = func(idx.values)
self.assertIsInstance(result, np.ndarray)
tm.assertNotIsInstance(result, Index)
else:
if len(idx) == 0:
continue
else:
with tm.assertRaises(Exception):
func(idx) 