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 numpy2bifrost(dtype):
if dtype == np.int8: return _bf.BF_DTYPE_I8
elif dtype == np.int16: return _bf.BF_DTYPE_I16
elif dtype == np.int32: return _bf.BF_DTYPE_I32
elif dtype == np.uint8: return _bf.BF_DTYPE_U8
elif dtype == np.uint16: return _bf.BF_DTYPE_U16
elif dtype == np.uint32: return _bf.BF_DTYPE_U32
elif dtype == np.float16: return _bf.BF_DTYPE_F16
elif dtype == np.float32: return _bf.BF_DTYPE_F32
elif dtype == np.float64: return _bf.BF_DTYPE_F64
elif dtype == np.float128: return _bf.BF_DTYPE_F128
elif dtype == ci8: return _bf.BF_DTYPE_CI8
elif dtype == ci16: return _bf.BF_DTYPE_CI16
elif dtype == ci32: return _bf.BF_DTYPE_CI32
elif dtype == cf16: return _bf.BF_DTYPE_CF16
elif dtype == np.complex64: return _bf.BF_DTYPE_CF32
elif dtype == np.complex128: return _bf.BF_DTYPE_CF64
elif dtype == np.complex256: return _bf.BF_DTYPE_CF128
else: raise ValueError("Unsupported dtype: " + str(dtype)) Example 2
def numpy2string(dtype):
if dtype == np.int8: return 'i8'
elif dtype == np.int16: return 'i16'
elif dtype == np.int32: return 'i32'
elif dtype == np.int64: return 'i64'
elif dtype == np.uint8: return 'u8'
elif dtype == np.uint16: return 'u16'
elif dtype == np.uint32: return 'u32'
elif dtype == np.uint64: return 'u64'
elif dtype == np.float16: return 'f16'
elif dtype == np.float32: return 'f32'
elif dtype == np.float64: return 'f64'
elif dtype == np.float128: return 'f128'
elif dtype == np.complex64: return 'cf32'
elif dtype == np.complex128: return 'cf64'
elif dtype == np.complex256: return 'cf128'
else: raise TypeError("Unsupported dtype: " + str(dtype)) Example 3
def watts_threshold(self, m): """ The watts threshold function. Input --------------- m [number] : Number of active neigbors Return --------------- [float] : Probability of activation """ if m >= self.params["params"]["threshold"]: return np.float128(self.params["params"]["p"]) else: return np.float128(0.0) return
Example 4
def bond_percolation(self, m): """ The bond percolation response function Input --------------- m [number] : Number of active neigbors Return --------------- [float] : Probability of activation """ if m > 0: return (np.float128(1.0) - np.float128((1.0 - self.params["params"]["p"]) ** m)*(1.0-np.float128(self.params["params"]["p_spontaneous"]))) else: return np.float128(self.params["params"]["p_spontaneous"])
Example 5
def json_encode(obj):
try:
serial = obj.to_json()
serial['classname'] = obj.__class__.__qualname__
return serial
except AttributeError:
pass
# Convert numpy types:
if type(obj) in [np.int8, np.int16, np.int32, np.int64]:
return int(obj)
elif type(obj) in [np.float16, np.float32, np.float64, np.float128]:
return float(obj)
elif isinstance(obj, np.ndarray):
return obj.tolist()
if isinstance(obj, datetime.datetime):
return obj.isoformat()
raise TypeError('Type not serialisable') Example 6
def test_returned_dtype(self):
dtypes = [np.int16, np.int32, np.int64, np.float32, np.float64]
if hasattr(np, 'float128'):
dtypes.append(np.float128)
for dtype in dtypes:
s = Series(range(10), dtype=dtype)
group_a = ['mean', 'std', 'var', 'skew', 'kurt']
group_b = ['min', 'max']
for method in group_a + group_b:
result = getattr(s, method)()
if is_integer_dtype(dtype) and method in group_a:
self.assertTrue(
result.dtype == np.float64,
"return dtype expected from %s is np.float64, "
"got %s instead" % (method, result.dtype))
else:
self.assertTrue(
result.dtype == dtype,
"return dtype expected from %s is %s, "
"got %s instead" % (method, dtype, result.dtype)) Example 7
def hashint64(x,N):
'''
Convert a bit vector to a float128
Not to be confused with `pylab.packbits`
Parameters
----------
x : boolean or binary vector
N : positive integer, number of bits in each vector
Returns
-------
int64 : integer, stored in int64, whose binary bits match x
'''
if N>63:
raise ValueError('No more than 63 bits can be safely stored in int64')
return x.dot(2**np.int64(np.arange(N))) Example 8
def hashfloat128(x,N):
'''
Convert a bit vector to a float128
Not to be confused with `pylab.packbits`
Parameters
----------
x : boolean or binary vector
N : positive integer, number of bits in each vector
Returns
-------
float128 : integer, stored in float128, whose binary bits match x
'''
x = (np.array(x)!=0)
if not x.shape[-1]==N:
raise ValueError('The last dimension of x should match the bit vector length N')
if N>63:
raise ValueError('No more than 63 bits are safe at the moment')
return x.dot(2**np.float128(np.arange(N))) Example 9
def unhashfloat128(x,N):
'''
Unpack bits from number b; inverse of `hashbits()`
Not to be confused with `pylab.unpackbits`
Parameters
----------
x : float128
integer stored in float128, whose binary bits match x
N : positive integer, number of bits in each vector
Returns
-------
b : boolean or binary vector, unpacked
'''
if not x.dtype==np.float128:
raise ValueError('Expected to unpack bit data from np.float128')
x = x.copy()
b = []
for i in range(N):
b.append(x%2)
x = np.floor(x*0.5)
b = (np.uint8(b)==1)
return b.T Example 10
def _is_class_a_primitive(cls):
'''
Check if class is a number or string including numpy numbers
:param cls: any class
:return: True if class is a primitive class, else False
'''
primitives = [
np.float16, np.float32, np.float64, np.float128,
np.int8, np.int16, np.int32, np.int64,
bool, str, np.uint8, np.uint16, np.uint32, np.uint64,
int, float
]
return cls in primitives Example 11
def softmax_cost(out,y, theta3, filt1, filt2): eout = np.exp(out, dtype=np.float128) probs = eout/sum(eout) p = sum(y*probs) cost = -np.log(p) ## (Only data loss. No regularised loss) return cost,probs ## Returns gradient for all the paramaters in each iteration
Example 12
def name_nbit2numpy(name, nbit):
if name == 'i':
if nbit == 8: return np.int8
elif nbit == 16: return np.int16
elif nbit == 32: return np.int32
elif nbit == 64: return np.int64
else: raise TypeError("Invalid signed integer type size: %i" % nbit)
elif name == 'u':
if nbit == 8: return np.uint8
elif nbit == 16: return np.uint16
elif nbit == 32: return np.uint32
elif nbit == 64: return np.uint64
else: raise TypeError("Invalid unsigned integer type size: %i" % nbit)
elif name == 'f':
if nbit == 16: return np.float16
elif nbit == 32: return np.float32
elif nbit == 64: return np.float64
elif nbit == 128: return np.float128
else: raise TypeError("Invalid floating-point type size: %i" % nbit)
elif name == 'ci':
if nbit == 8: return ci8
elif nbit == 16: return ci16
elif nbit == 32: return ci32
# elif name in set(['ci', 'cu']):
# Note: This gives integer types in place of proper complex types
# return name_nbit2numpy(name[1:], nbit*2)
elif name == 'cf':
if nbit == 16: return cf16
elif nbit == 32: return np.complex64
elif nbit == 64: return np.complex128
elif nbit == 128: return np.complex256
else: raise TypeError("Invalid complex floating-point type size: %i" %
nbit)
else:
raise TypeError("Invalid type name: " + name) Example 13
def test_16byte(self):
self.run_simple_test_shmoo(np.float128) Example 14
def _print_Float(self, expr):
super_float = super()._print_Float(expr)
if self._settings['float128']:
super_float = 'float128(%r)' % super_float
if self._settings['use_autoeye']:
return 'autoeye(%s)' % super_float
return super_float Example 15
def print_features_info(dataset):
features_and_types = dataset.dtypes
print("\n[Debug] Print the feature number: ")
numberic_feature_number = 0
not_numberic_feature_number = 0
for feature_type in features_and_types:
if feature_type == np.int16 or feature_type == np.int32 or feature_type == np.int64 or feature_type == np.float16 or feature_type == np.float32 or feature_type == np.float64 or feature_type == np.float128 or feature_type == np.double:
numberic_feature_number += 1
else:
not_numberic_feature_number += 1
print("Total feature number: {}".format(len(features_and_types)))
print("Numberic feature number: {}".format(numberic_feature_number))
print("Not numberic feature number: {}".format(not_numberic_feature_number))
print("\n[Debug] Print the feature list of the dataset: ")
print(features_and_types)
print("\n[Debug] Print the feature presence: ")
example_number = len(dataset)
features_array = list(dataset.columns.values)
for feature_name in features_array:
feature_presence_number = len(dataset[feature_name][dataset[feature_name].notnull()])
feature_presence_percentage = 100.0 * feature_presence_number / example_number
# Example: "Age: 80.1346801347% (714 / 891)"
print("{}: {}% ({} / {})".format(feature_name, feature_presence_percentage, feature_presence_number, example_number))
print("\n[Debug] For numberic features, print the feature statistics: ")
feature_statistics = dataset.describe()
print(feature_statistics)
top_k_number = 5
print("\n[Debug] For all features, print the top {} values: ".format(top_k_number))
for i in range(len(features_array)):
feature_name = features_array[i]
top_k_feature_info = dataset[feature_name].value_counts()[:top_k_number]
print("\nFeature {} and the top {} values:".format(feature_name, top_k_number))
print(top_k_feature_info) Example 16
def test_scalar():
res = x2num.makenp(1.1)
assert isinstance(res, np.ndarray) and res.shape == (1,)
res = x2num.makenp(1000000000000000000000)
assert isinstance(res, np.ndarray) and res.shape == (1,)
res = x2num.makenp(np.float16(1.00000087))
assert isinstance(res, np.ndarray) and res.shape == (1,)
res = x2num.makenp(np.float128(1.00008+9))
assert isinstance(res, np.ndarray) and res.shape == (1,)
res = x2num.makenp(np.int64(100000000000))
assert isinstance(res, np.ndarray) and res.shape == (1,) Example 17
def _float(value):
t = type(value)
floats = [np.float, np.float32, np.float64, np.float128, np.float16, float]
return bool(np.sum([t is f for f in floats])) Example 18
def test_numpy_float128(self):
x = numpy.float128(55.3)
s = Serializable.dumps(x)
y = Serializable.from_json(s)
self.assertAlmostEqual(x, y, 5)
self.assertEqual(str(x.dtype), 'float128')
self.assertEqual(str(y.dtype), 'float128') Example 19
def get_full_conditional(self, sentence, m, z, n_z, n_m_z):
prod_nom, prod_den = [] , []
words = Counter(sentence)
for key, val in words.iteritems():
for x in range(val):
quantity = self.n_z_t[:,key] + self.beta + x
prod_nom.append(quantity)
# prod_nom *= (quantity)
prod_nom = np.array(prod_nom, dtype=np.float128)
left_denominator = n_z + self.beta*self.V
for x in range(len(sentence)):
quantity = left_denominator + x
prod_den.append(quantity)
# prod_den *= (quantity)
prod_den = np.array(prod_den, dtype=np.float128)
# print "Shapes of interest:", prod_den.shape, prod_nom.shape
prodall1 = np.divide(prod_nom,prod_den)
# print "After division:", prodall.shape
prodall = np.prod(prodall1, axis=0)
# print "After multiplication", prodall.shape
# prod_nom = np.prod(prod_nom, axis=0, dtype=np.float128)
# prod_den = np.prod(prod_den, axis=0, dtype=np.float128)
# left = prod_nom/prod_den
right = (n_m_z[m,:] + self.alpha)
p_z = prodall*right
# try:
# p_z /= np.sum(p_z)
# except:
# print p_z
# print prodall1
# print prodall
p_z /= np.sum(p_z)
# except RuntimeWarning:
# print 'Exception'
# print prodall
# print right
# print self.n_z_t[:,key]
return p_z.astype(np.float64) Example 20
def test_response_function(self):
"""
Verify the response functions
"""
for node in self.solver.G.nodes():
self.assertIn("rf", self.solver.G.node[node])
self.assertIsInstance(self.solver.G.node[node]["rf"], ResponseFunction )
self.assertIs(type(self.solver.G.node[node]["rf"].resp_func(0.0)), np.float128)
self.assertIs(type(self.solver.G.node[node]["rf"].resp_func(20.0)), np.float128) Example 21
def get_probabilities_Q_possible(self, possible_configs):
"""
Get the probability Q(l;n) for each configuration in the possible_configs dictionnary.
The implementation is based on the recursive equation of the paper.
Input
----------------------
possible_configs: Dictionnary where keys are the config as a string (i.e. "0101011011") and value are sets of the parent configurations.
Return
----------------------
Dictionnary of probabilities where the key is the configuration as a string (e.g. "10101110") and the value is Q(l;n)
"""
#the master dictionnary
dict_config = {}
prob_tot = 1.0
#order by size to simplify the calculation
possible_config_ordered_by_size = self.regroup_config_by_size(possible_configs)
N = len(self.G.nodes())
#Initial configuration
initial_config = [0]*N
if self.symbolic_:
dict_config[self.list_to_string(initial_config)] = "<prod>"+";".join(["G("+str(node)+","+str(0)+")" for node in self.G.nodes()])+"</prod>"
else:
dict_config[self.list_to_string(initial_config)] = np.float128(np.product([(1.0-self.G.nodes[node]["rf"].resp_func(0)) for node in self.G.nodes()]))
prob_tot -= dict_config[self.list_to_string(initial_config)]
for size in range(1,N+1):
if size in possible_config_ordered_by_size:
for config_str in possible_config_ordered_by_size[size]:
Q_ln = self.solve_specific_configuration(config_str, dict_config, possible_configs)
dict_config[config_str] = Q_ln
prob_tot -= Q_ln
dict_config["1"*N] = prob_tot
return dict_config Example 22
def jk(D,Bs,i,j,frac,possible,ri):
Num=factorial(ri-1)
Den=factorial(N_ij(D,Bs,i,j,ri)+ri-1)
frac*=np.float128(Num)/np.float128(Den)
for k in range(0,ri):
frac*=factorial(N_ijk(D,Bs,i,j,k,ri))
if N_ijk(D,Bs,i,j,k,ri)!=0 :
possible=1
return frac,possible Example 23
def getCsvData():
dtypes = {
"int8_value": numpy.int8,
"int16_value": numpy.int16,
"int32_value": numpy.int32,
# "int64_value": numpy.int64, # OverFlowError
"uint8_value": numpy.uint8,
"uint16_value": numpy.uint16,
"uint32_value": numpy.uint32,
# "uint64_value": numpy.uint64, # OverFlowError
"float16_value": numpy.float16,
"float32_value": numpy.float32,
"float64_value": numpy.float64,
# "float128_value": numpy.float128,
"bool_value": numpy.bool_
}
delimiter = ","
encoding = "utf-8"
parse_dates = ["timestamp_value"]
path = os.path.join(os.getcwdu(), "examples/testData/test1.csv")
if not os.path.exists(path):
path = os.path.join(os.getcwdu(), "testData/test1.csv")
df = pandas.read_csv(
path,
dtype=dtypes,
delimiter=delimiter,
encoding=encoding,
parse_dates=parse_dates
)
try:
df["int64_value"] = df["int64_value"].astype(numpy.int64)
df["uint64_value"] = df["uint64_value"].astype(numpy.uint64)
except:
raise
return df Example 24
def get_worst_live_point(self):
"""
selects the lowest likelihood live point
"""
logL_array = np.array([p.logL for p in self.params])
self.worst = logL_array.argmin()
self.logLmin.value = logL_array[self.worst]
self.logLmax = np.max(logL_array)
return np.float128(self.logLmin.value) Example 25
def poisson_logpdf(k,l):
'''
Gives the log-pdf for a poisson distribution with rate l
evaluated at points k. k should be a vector of integers.
Parameters
----------
Returns
-------
'''
# k,l = map(np.float128,(k,l))
return k*slog(l)-l-np.array([scipy.special.gammaln(x+1) for x in k])
#return k*slog(l)-l-np.array([log_factorial(x) for x in k]) Example 26
def gaussian_logpdf(mu,sigma,x):
'''
Non-positive standar deviations will be clipped
Parameters
----------
Returns
-------
'''
mu,sigma,x = map(np.float128,(mu,sigma,x))
x = (x-mu)/sigma
return -0.5*x*x - slog(sigma) - logsqrt2pi Example 27
def sigmoid(x,returntype=LINALGMAXFLOAT):
'''
Soft-threshold function (rescaled hyperbolic tangent)
More numerically stable version
'''
return returntype(sexp(-np.logaddexp(ZERO128,-np.float128(x))))
# Sigmoid and derivatives Example 28
def g(x,returntype=LINALGMAXFLOAT):
'''
Evaluates g(x)=log(1+exp(x)) as accurately as possible.
'''
return returntype(np.logaddexp(ZERO128,np.float128(x))) Example 29
def f(x,returntype=LINALGMAXFLOAT):
'''
evaluates f(x)=1/(1+exp(-x)) as accurately as possible
'''
return returntype(sexp(-np.logaddexp(ZERO128,-np.float128(x)))) Example 30
def f1(x,returntype=LINALGMAXFLOAT):
'''
Fist derivative of sigmoid
'''
x = np.float128(x)
return sexp(\
-np.logaddexp(ZERO128,-x)\
-np.logaddexp(ZERO128,x),
returntype=returntype) Example 31
def f2(x,returntype=LINALGMAXFLOAT):
'''
Second derivative of sigmoid
(q - p) p q
'''
x = np.float128(x)
logp = -np.logaddexp(ZERO128,-x)
logq = -np.logaddexp(ZERO128, x)
p = np.exp(np.minimum(F128EMAX,logp))
q = np.exp(np.minimum(F128EMAX,logq))
return returntype((q-p)*q*p); Example 32
def sample_patch_projective(image, inv_xform_3x3, patch_shape):
""" return a warped image as a numpy array with dtype float64 of size patch_size.
if input image is not already of type float64, it will be converted """
P = skimage.transform.ProjectiveTransform(inv_xform_3x3)
# skimage clips values to range [0,1] for floating point images. do scale and unscale here.
do_scale = False
og_dtype = image.dtype
if image.dtype in (np.float32, np.float64, np.float128, np.float16):
minval = np.nanmin(image)
maxval = np.nanmax(image)
# if range is good, no need to rescale
if minval < 0.0 or maxval > 1.0:
do_scale = True
# make a copy of image so as not to corrupt original data
image = image.copy()
scale_factor = maxval - minval
image -= minval
if scale_factor != 0:
image /= scale_factor
# do the warping
patch = skimage.transform.warp(image, P, output_shape=patch_shape, mode='constant', cval=np.nan)
# revert to original type if necessary
if og_dtype != patch.dtype:
if og_dtype == np.uint8:
patch = skimage.img_as_ubyte(patch)
elif og_dtype == np.bool:
patch = skimage.img_as_bool(patch)
elif og_dtype == np.uint16:
patch = skimage.img_as_uint(patch)
elif og_dtype == np.int16:
patch = skimage.img_as_int(patch)
else:
# just to straight cast, hope for the best
patch_out = np.zeros(patch.shape, og_dtype)
np.copyto(patch_out,patch)
patch = patch_out
# unscale if necessary
if do_scale:
patch *= scale_factor
patch += minval
return patch 