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 resample(image, scan, new_spacing=[1,1,1]):
# Determine current pixel spacing
spacing = map(float, ([scan[0].SliceThickness] + scan[0].PixelSpacing))
spacing = np.array(list(spacing))
#scan[2].SliceThickness
resize_factor = spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
real_resize_factor = new_shape / image.shape
new_spacing = spacing / real_resize_factor
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest') ### early orig modified
return image, new_spacing Example 2
def resample(image, scan, new_spacing=[1,1,1]):
# Determine current pixel spacing
spacing = map(float, ([scan[0].SliceThickness] + scan[0].PixelSpacing))
spacing = np.array(list(spacing))
resize_factor = spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
real_resize_factor = new_shape / image.shape
new_spacing = spacing / real_resize_factor
#image = scipy.ndimage.interpolation.zoom(image, real_resize_factor) # nor mode= "wrap"/xxx, nor cval=-1024 can ensure that the min and max values are unchanged .... # cval added
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest') ### early orig modified
#image = scipy.ndimage.zoom(image, real_resize_factor, order=1) # order=1 bilinear , preserves the min and max of the image -- pronbably better for us (also faster than spkine/order=2)
#image = scipy.ndimage.zoom(image, real_resize_factor, mode='nearest', order=1) # order=1 bilinear , preserves the min and max of the image -- pronbably better for us (also faster than spkine/order=2)
return image, new_spacing Example 3
def handle_data(self, data):
if self.target_shares == 0:
assert 0 not in self.portfolio.positions
self.order(self.sid(0), 10)
self.target_shares = 10
return
else:
print(self.portfolio)
assert self.portfolio.positions[0]['amount'] == \
self.target_shares, "Orders not filled immediately."
assert self.portfolio.positions[0]['last_sale_price'] == \
data[0].price, "Orders not filled at current price."
self.order_target_value(self.sid(0), 20)
self.target_shares = np.round(20 / data[0].price)
if isinstance(self.sid(0), Equity):
self.target_shares = np.round(20 / data[0].price)
if isinstance(self.sid(0), Future):
self.target_shares = np.round(
20 / (data[0].price * self.sid(0).multiplier)) Example 4
def round_to_chunk_size(self, chunk_size, offset=Vec(0,0,0, dtype=int)):
"""
Align a potentially non-axis aligned bbox to the grid by rounding it
to the nearest grid lines.
Required:
chunk_size: arraylike (x,y,z), the size of chunks in the
dataset e.g. (64,64,64)
Optional:
offset: arraylike (x,y,z), the starting coordinate of the dataset
"""
chunk_size = np.array(chunk_size, dtype=np.float32)
result = self.clone()
result = result - offset
result.minpt = np.round(result.minpt / chunk_size) * chunk_size
result.maxpt = np.round(result.maxpt / chunk_size) * chunk_size
return result + offset Example 5
def draw_bounding_boxes(image, gt_boxes, im_info):
num_boxes = gt_boxes.shape[0]
gt_boxes_new = gt_boxes.copy()
gt_boxes_new[:,:4] = np.round(gt_boxes_new[:,:4].copy() / im_info[2])
disp_image = Image.fromarray(np.uint8(image[0]))
for i in xrange(num_boxes):
this_class = int(gt_boxes_new[i, 4])
disp_image = _draw_single_box(disp_image,
gt_boxes_new[i, 0],
gt_boxes_new[i, 1],
gt_boxes_new[i, 2],
gt_boxes_new[i, 3],
'N%02d-C%02d' % (i, this_class),
FONT,
color=STANDARD_COLORS[this_class % NUM_COLORS])
image[0, :] = np.array(disp_image)
return image Example 6
def quantized_forward_pass_cost_and_output(inputs, weights, scales, biases=None, quantization_method='round',
hidden_activations='relu', output_activation = 'relu', computation_calc='adds', seed=None):
"""
Do a forward pass of a discretized network, and return the (pseudo) computational cost and final output.
:param inputs: A (n_samples, n_dims) array of inputs
:param weights: A list of (n_dim_in, n_dim_out) arrays of weights
:param scales: A list of (w[0].shape[0], w[1].shape[0], ...) scales to multiply/divide by before/after the quantization
:param quantization_method: The method of quantization/discretization: 'round', 'uniform', None, ....
:param seed: A random seed or number generator
:return: n_ops, output_activation: Where:
n_ops is the (scalar) number of commputations required in the forward pass (only striclty true if scale is 'round', .. otherwise it's some kind of surrogate.
output_activation: A (n_samples, n_dims) array representing the output activations.
"""
activations = scaled_quantized_forward_pass(inputs= inputs, weights=weights, biases=biases, scales=scales,
hidden_activations=hidden_activations, output_activations=output_activation, quantization_method=quantization_method, rng=seed)
spike_activations = activations[1::3]
n_ops = sparse_nn_flop_count(spike_activations, [w.shape[1] for w in weights], mode=computation_calc) if quantization_method is not None else None
return n_ops, activations[-1] Example 7
def resample(patient, new_spacing=[1,1,1]):
scan = get_scan(patient)
image = get_3D_data(patient)
# Determine current pixel spacing
spacing = np.array([scan[0].SliceThickness] + scan[0].PixelSpacing, dtype=np.float32)
resize_factor = spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
real_resize_factor = new_shape / image.shape
new_spacing = spacing / real_resize_factor
image = nd.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image
# For the sake of testing the network, we'll be using the sample dataset
# For this, we'll use the maximum size of the image
# and PAD any image with -1000 values which is smaller than that
#PS: only the first dimension is different in sample dataset
#which is not the case in actual dataset Example 8
def did_succeed( output_dict, cond_dict ):
'''
Used in rejection sampling:
for each row, determine if cond is satisfied
for every cond in cond_dict
success is hardcoded as round(label) being exactly equal
to the integer in cond_dict
'''
#definition success:
def is_win(key):
#cond=np.squeeze(cond_dict[key])
cond=np.squeeze(cond_dict[key])
val=np.squeeze(output_dict[key])
condition= np.round(val)==cond
return condition
scoreboard=[is_win(key) for key in cond_dict]
#print('scoreboard', scoreboard)
all_victories_bool=np.logical_and.reduce(scoreboard)
return all_victories_bool.flatten() Example 9
def func_impl(self, x):
objval, invalid = None, False
for i, t in enumerate(x):
if t < self.p_min[i] or t > self.p_max[i]:
objval = float("inf")
invalid = True
if not invalid:
x = [int(np.round(x_t)) if p_t is "integer" else x_t for p_t, x_t in zip(self.p_types, x)]
objval = self._coef * self.func(x)
print("{:5d} | {} | {:>15.5f}".format(
self.n_eval,
" | ".join(["{:>15.5f}".format(t) for t in x]),
self._coef * objval
))
self.n_eval += 1
return objval Example 10
def clean_height(df):
v = df.VALUE.astype(float)
idx = df.VALUEUOM.fillna('').apply(lambda s: 'in' in s.lower()) | df.MIMIC_LABEL.apply(lambda s: 'in' in s.lower())
v.ix[idx] = np.round(v[idx] * 2.54)
return v
# ETCO2: haven't found yet
# Urine output: ambiguous units (raw ccs, ccs/kg/hr, 24-hr, etc.)
# Tidal volume: tried to substitute for ETCO2 but units are ambiguous
# Glascow coma scale eye opening
# Glascow coma scale motor response
# Glascow coma scale total
# Glascow coma scale verbal response
# Heart Rate
# Respiratory rate
# Mean blood pressure Example 11
def test_sample_NormalFloatHyperparameter(self):
hp = NormalFloatHyperparameter("nfhp", 0, 1)
def actual_test():
rs = np.random.RandomState(1)
counts_per_bin = [0 for i in range(11)]
for i in range(100000):
value = hp.sample(rs)
index = min(max(int((round(value + 0.5)) + 5), 0), 9)
counts_per_bin[index] += 1
self.assertEqual([0, 4, 138, 2113, 13394, 34104, 34282, 13683,
2136, 146, 0], counts_per_bin)
return counts_per_bin
self.assertEqual(actual_test(), actual_test()) Example 12
def round_solution_pool(pool, constraints):
pool.distinct().sort()
P = pool.P
L0_reg_ind = np.isnan(constraints['coef_set'].C_0j)
L0_max = constraints['L0_max']
rounded_pool = SolutionPool(P)
for solution in pool.solutions:
# sort from largest to smallest coefficients
feature_order = np.argsort([-abs(x) for x in solution])
rounded_solution = np.zeros(shape=(1, P))
l0_norm_count = 0
for k in range(0, P):
j = feature_order[k]
if not L0_reg_ind[j]:
rounded_solution[0, j] = np.round(solution[j], 0)
elif l0_norm_count < L0_max:
rounded_solution[0, j] = np.round(solution[j], 0)
l0_norm_count += L0_reg_ind[j]
rounded_pool.add(objvals=np.nan, solutions=rounded_solution)
rounded_pool.distinct().sort()
return rounded_pool Example 13
def resize(im, target_size, max_size):
"""
only resize input image to target size and return scale
:param im: BGR image input by opencv
:param target_size: one dimensional size (the short side)
:param max_size: one dimensional max size (the long side)
:return:
"""
im_shape = im.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
im_scale = float(target_size) / float(im_size_min)
# prevent bigger axis from being more than max_size:
if np.round(im_scale * im_size_max) > max_size:
im_scale = float(max_size) / float(im_size_max)
im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)
return im, im_scale Example 14
def resize(im, target_size, max_size):
"""
only resize input image to target size and return scale
:param im: BGR image input by opencv
:param target_size: one dimensional size (the short side)
:param max_size: one dimensional max size (the long side)
:return:
"""
im_shape = im.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
im_scale = float(target_size) / float(im_size_min)
if np.round(im_scale * im_size_max) > max_size:
im_scale = float(max_size) / float(im_size_max)
im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR)
return im, im_scale Example 15
def generateTickText(tickValue, ratio, baseline=False):
multStep = 1000.
multipliers = [
dict(suffix='', mult=pow(multStep, 0)),
dict(suffix='k', mult=pow(multStep, 1)),
dict(suffix='M', mult=pow(multStep, 2)),
dict(suffix='G', mult=pow(multStep, 3)),
]
multiplier = multipliers[0]
for m in multipliers:
if np.round(tickValue / m['mult'], decimals=2) >= 1:
multiplier = m
baseText = float('%.3g' % np.round(tickValue / multiplier['mult'], decimals=2))
baseText = int(baseText) if int(baseText) == baseText else baseText
suffix = multiplier['suffix']
percent = float('%.1f' % (100 * ratio))
percent = int(percent) if percent == int(percent) else percent
return '%s%s [%s%%]' % (baseText, suffix, percent) Example 16
def generateTickText(tickValue, ratio, baseline = False):
multStep = 1000.
multipliers = [
dict(suffix='', mult=pow(multStep, 0)),
dict(suffix='k', mult=pow(multStep, 1)),
dict(suffix='M', mult=pow(multStep, 2)),
dict(suffix='G', mult=pow(multStep, 3)),
]
multiplier = multipliers[0]
for m in multipliers:
if np.round(tickValue / m['mult']) >= 1:
multiplier = m
baseText = float('%.3g' % np.round(tickValue / multiplier['mult']))
baseText = int(baseText) if int(baseText) == baseText else baseText
suffix = multiplier['suffix']
percent = float('%.1f' % (100 * ratio))
percent = int(percent) if percent == int(percent) else percent
return '%s%s [%s%%]' % (baseText, suffix, percent) Example 17
def apply_regr(x, y, w, h, tx, ty, tw, th): try: cx = x + w/2. cy = y + h/2. cx1 = tx * w + cx cy1 = ty * h + cy w1 = math.exp(tw) * w h1 = math.exp(th) * h x1 = cx1 - w1/2. y1 = cy1 - h1/2. x1 = int(round(x1)) y1 = int(round(y1)) w1 = int(round(w1)) h1 = int(round(h1)) return x1, y1, w1, h1 except ValueError: return x, y, w, h except OverflowError: return x, y, w, h except Exception as e: print(e) return x, y, w, h
Example 18
def prep_im_for_blob(im, pixel_means, target_size, max_size):
"""Mean subtract and scale an image for use in a blob."""
im = im.astype(np.float32, copy=False)
im -= pixel_means
im = im / 127.5
im_shape = im.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
im_scale = float(target_size) / float(im_size_min)
# Prevent the biggest axis from being more than MAX_SIZE
if np.round(im_scale * im_size_max) > max_size:
im_scale = float(max_size) / float(im_size_max)
im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale,
interpolation=cv2.INTER_LINEAR)
return im, im_scale Example 19
def _gene_embed_space(self,vec):
shape = vec.shape
vec = vec.flatten()
combo_neg_idx = np.array([1 if vec[i]<0 else 0 for i in range(len(vec))])
vec_pos = np.abs(vec)
int_part = np.floor(vec_pos)
frac_part = np.round(vec_pos - int_part,2)
bi_int_part=[] #?????????????signature???????
for i in range(len(int_part)):
bi=list(bin(int(int_part[i]))[2:])
bie = [0] * (16 - len(bi))
bie.extend(bi)
bi_int_part.append(np.array(bie,dtype=np.uint16))
bi_int_part = np.array(bi_int_part)
sig = []
for i in range(len(bi_int_part)):
sig.append(bi_int_part[i][10])
sig = np.array(sig).reshape(shape)
return np.array(bi_int_part),frac_part.reshape(shape),combo_neg_idx.reshape(shape),sig Example 20
def _gene_embed_space(self,vec):
shape = vec.shape
vec = vec.flatten()
combo_neg_idx = np.array([1 if vec[i]<0 else 0 for i in range(len(vec))])
vec_pos = np.abs(vec)
int_part = np.floor(vec_pos)
frac_part = np.round(vec_pos - int_part,2)
bi_int_part=[] #?????????????signature???????
for i in range(len(int_part)):
bi=list(bin(int(int_part[i]))[2:])
bie = [0] * (16 - len(bi))
bie.extend(bi)
bi_int_part.append(np.array(bie,dtype=np.uint16))
bi_int_part = np.array(bi_int_part)
sig = []
for i in range(len(bi_int_part)):
sig.append(bi_int_part[i][10])
sig = np.array(sig).reshape(shape)
return np.array(bi_int_part),frac_part.reshape(shape),combo_neg_idx.reshape(shape),sig Example 21
def crop_pad(image, corner, shape):
ndim = len(corner)
corner = [int(round(c)) for c in corner]
shape = [int(round(s)) for s in shape]
original = image.shape[-ndim:]
zipped = zip(corner, shape, original)
if np.any(c < 0 or c + s > o for (c, s, o) in zipped):
no_padding = [(0, 0)] * (image.ndim - ndim)
padding = [(max(-c, 0), max(c + s - o, 0)) for (c, s, o) in zipped]
corner = [c + max(-c, 0) for c in corner]
image_temp = np.pad(image, no_padding + padding, mode=str('constant'))
else:
image_temp = image
no_crop = [slice(o+1) for o in image.shape[:-ndim]]
crop = [slice(c, c+s) for (c, s) in zip(corner, shape)]
return image_temp[no_crop + crop] Example 22
def tslsr(image):
"""
Takes an image then returns (mask, circles, rois for each circle)
"""
image_hsv = cv2.cvtColor(cv2.GaussianBlur(image, (7, 7), 0), cv2.COLOR_BGR2HSV)
mask = __filterRedColor(image_hsv)
circles = __findCircles(mask)
rois = []
if circles is not None:
circles = np.round(circles[0, :]).astype("int")
for (x, y, r) in circles:
rois.append(__extract_sign_roi(image, (x, y, r)))
return (mask, circles, rois) Example 23
def apply_regr(x, y, w, h, tx, ty, tw, th): try: cx = x + w/2. cy = y + h/2. cx1 = tx * w + cx cy1 = ty * h + cy w1 = math.exp(tw) * w h1 = math.exp(th) * h x1 = cx1 - w1/2. y1 = cy1 - h1/2. x1 = int(round(x1)) y1 = int(round(y1)) w1 = int(round(w1)) h1 = int(round(h1)) return x1, y1, w1, h1 except ValueError: return x, y, w, h except OverflowError: return x, y, w, h except Exception as e: print(e) return x, y, w, h
Example 24
def compute_centroids(object_matrix, preserve_ids=False, round_val=False):
# if ids=true, then write a matrix equal to size of maximum
# value, else, order in object label order
# if round = true, round centroid coordinates to nearest integer
# when rounding, TODO: make sure we don't leave the volume
import skimage.measure as measure
centroids = []
# Threshold data
rp = measure.regionprops(object_matrix)
for r in rp:
if round_val > 0:
centroids.append(np.round(r.Centroid, round_val))
else:
centroids.append(r.Centroid)
return centroids Example 25
def pareto_front(vals1, vals2, round_val=3):
# butter and guns pareto front. Removes points not on
# the pareto frontier
# round very similar vals
vals1 = round(vals1, round_val)
vals2 = round(vals2, round_val)
v1_out = []
v2_out = []
idx_out = []
for idx in range(0, len(vals1)):
is_better = np.find(vals1 >= vals1[idx] and vals2 >= vals2[idx])
if is_better is None:
v1_out.append(vals1[idx])
v2_out.append(vals2[idx])
idx_out.append(idx)
return v1_out, v2_out, idx_out Example 26
def _downsample_mask(X, pct):
""" Create a boolean mask indicating which subset of X should be
evaluated.
"""
if pct < 1.0:
Mask = np.zeros(X.shape, dtype=np.bool)
m = X.shape[-2]
n = X.shape[-1]
nToEval = np.round(pct*m*n).astype(np.int32)
idx = sobol(2, nToEval ,0)
idx[0] = np.floor(m*idx[0])
idx[1] = np.floor(n*idx[1])
idx = idx.astype(np.int32)
Mask[:,:,idx[0], idx[1]] = True
else:
Mask = np.ones(X.shape, dtype=np.bool)
return Mask Example 27
def prepare_oae_PU4(known_transisitons):
print("Learn from pre + action label",
"*** INCOMPATIBLE MODEL! ***",
sep="\n")
N = known_transisitons.shape[1] // 2
y = generate_oae_action(known_transisitons)
ind = np.where(np.squeeze(combined(y[:,N:])) > 0.5)[0]
y = y[ind]
actions = oae.encode_action(known_transisitons, batch_size=1000).round()
positive = np.concatenate((known_transisitons[:,:N], np.squeeze(actions)), axis=1)
actions = oae.encode_action(y, batch_size=1000).round()
negative = np.concatenate((y[:,:N], np.squeeze(actions)), axis=1)
# random.shuffle(negative)
# negative = negative[:len(positive)]
# normalize
return (default_networks['PUDiscriminator'], *prepare_binary_classification_data(positive, negative)) Example 28
def prepare_oae_PU5(known_transisitons):
print("Learn from pre + suc + action label",
"*** INCOMPATIBLE MODEL! ***",
sep="\n")
N = known_transisitons.shape[1] // 2
y = generate_oae_action(known_transisitons)
ind = np.where(np.squeeze(combined(y[:,N:])) > 0.5)[0]
y = y[ind]
actions = oae.encode_action(known_transisitons, batch_size=1000).round()
positive = np.concatenate((known_transisitons, np.squeeze(actions)), axis=1)
actions = oae.encode_action(y, batch_size=1000).round()
negative = np.concatenate((y, np.squeeze(actions)), axis=1)
# random.shuffle(negative)
# negative = negative[:len(positive)]
# normalize
return (default_networks['PUDiscriminator'], *prepare_binary_classification_data(positive, negative)) Example 29
def puzzle_plot(p):
p.setup()
def name(template):
return template.format(p.__name__)
from itertools import islice
configs = list(islice(p.generate_configs(9), 1000)) # be careful, islice is not immutable!!!
import numpy.random as random
random.shuffle(configs)
configs = configs[:10]
puzzles = p.generate(configs, 3, 3)
print(puzzles.shape, "mean", puzzles.mean(), "stdev", np.std(puzzles))
plot_image(puzzles[-1], name("{}.png"))
plot_image(np.clip(puzzles[-1]+np.random.normal(0,0.1,puzzles[-1].shape),0,1),name("{}+noise.png"))
plot_image(np.round(np.clip(puzzles[-1]+np.random.normal(0,0.1,puzzles[-1].shape),0,1)),name("{}+noise+round.png"))
plot_grid(puzzles, name("{}s.png"))
_transitions = p.transitions(3,3,configs=configs)
print(_transitions.shape)
transitions_for_show = \
np.einsum('ba...->ab...',_transitions) \
.reshape((-1,)+_transitions.shape[2:])
print(transitions_for_show.shape)
plot_grid(transitions_for_show, name("{}_transitions.png")) Example 30
def point_trans(ori_point, angle, ori_shape, new_shape):
""" Transfrom the point from original to rotated image.
Args:
ori_point: Point coordinates in original image.
angle: Rotate angle.
ori_shape: The shape of original image.
new_shape: The shape of rotated image.
Returns:
Numpy array of new point coordinates in rotated image.
"""
dx = ori_point[0] - ori_shape[1] / 2.0
dy = ori_point[1] - ori_shape[0] / 2.0
t_x = round(dx * math.cos(angle) - dy * math.sin(angle) + new_shape[1] / 2.0)
t_y = round(dx * math.sin(angle) + dy * math.cos(angle) + new_shape[0] / 2.0)
return np.array((int(t_x), int(t_y))) Example 31
def predict_tf_once(day,start_date = '2016-10-1'):
all_dataset = get_dataset(day)
all_dataset = map(lambda x:x.ix[start_date:start_date],all_dataset)
y_p_features = map(lambda user_id:tf_percent_model.resample_x_y_(all_dataset,user_id)[0].reshape(-1),get_full_user_ids())
y_p_features_df = pd.DataFrame(y_p_features,index = get_full_user_ids())
percent = pd.DataFrame.from_csv('./features/tensorflow_model/percent_model/%d.csv'%day)
#percent = pd.DataFrame.from_csv('./features/tensorflow_model/percent_model/%d.csv'%2)
#%%
percent = percent[map(lambda x:'percent#%d'%x,range(_feature_length))]
t = pd.DataFrame(index = percent.index)
t[pd.Timestamp(start_date)+pd.Timedelta('%dd'%(day-1))] = (np.array(y_p_features_df)*percent).sum(axis=1)
t = t.T
t.to_csv('./result/predict_part/%d.csv'%day)
real = int(np.round((np.array(y_p_features_df)*percent).sum().sum()))
print (day,real)
return (day,real) Example 32
def test_minmax_funcs_with_output(self):
# Tests the min/max functions with explicit outputs
mask = np.random.rand(12).round()
xm = array(np.random.uniform(0, 10, 12), mask=mask)
xm.shape = (3, 4)
for funcname in ('min', 'max'):
# Initialize
npfunc = getattr(np, funcname)
mafunc = getattr(numpy.ma.core, funcname)
# Use the np version
nout = np.empty((4,), dtype=int)
try:
result = npfunc(xm, axis=0, out=nout)
except MaskError:
pass
nout = np.empty((4,), dtype=float)
result = npfunc(xm, axis=0, out=nout)
self.assertTrue(result is nout)
# Use the ma version
nout.fill(-999)
result = mafunc(xm, axis=0, out=nout)
self.assertTrue(result is nout) Example 33
def test_round(self):
a = array([1.23456, 2.34567, 3.45678, 4.56789, 5.67890],
mask=[0, 1, 0, 0, 0])
assert_equal(a.round(), [1., 2., 3., 5., 6.])
assert_equal(a.round(1), [1.2, 2.3, 3.5, 4.6, 5.7])
assert_equal(a.round(3), [1.235, 2.346, 3.457, 4.568, 5.679])
b = empty_like(a)
a.round(out=b)
assert_equal(b, [1., 2., 3., 5., 6.])
x = array([1., 2., 3., 4., 5.])
c = array([1, 1, 1, 0, 0])
x[2] = masked
z = where(c, x, -x)
assert_equal(z, [1., 2., 0., -4., -5])
c[0] = masked
z = where(c, x, -x)
assert_equal(z, [1., 2., 0., -4., -5])
assert_(z[0] is masked)
assert_(z[1] is not masked)
assert_(z[2] is masked) Example 34
def test_round_with_scalar(self):
# Testing round with scalar/zero dimension input
# GH issue 2244
a = array(1.1, mask=[False])
assert_equal(a.round(), 1)
a = array(1.1, mask=[True])
assert_(a.round() is masked)
a = array(1.1, mask=[False])
output = np.empty(1, dtype=float)
output.fill(-9999)
a.round(out=output)
assert_equal(output, 1)
a = array(1.1, mask=[False])
output = array(-9999., mask=[True])
a.round(out=output)
assert_equal(output[()], 1)
a = array(1.1, mask=[True])
output = array(-9999., mask=[False])
a.round(out=output)
assert_(output[()] is masked) Example 35
def dec_round(num, dprec=4, rnd='down', rto_zero=False):
"""
Round up/down numeric ``num`` at specified decimal ``dprec``.
Parameters
----------
num: float
dprec: int
Decimal position for truncation.
rnd: str (default: 'down')
Set as 'up' or 'down' to return a rounded-up or rounded-down value.
rto_zero: bool (default: False)
Use a *round-towards-zero* method, e.g., ``floor(-3.5) == -3``.
Returns
----------
float (default: rounded-up)
"""
dprec = 10**dprec
if rnd == 'up' or (rnd == 'down' and rto_zero and num < 0.):
return np.ceil(num*dprec)/dprec
elif rnd == 'down' or (rnd == 'up' and rto_zero and num < 0.):
return np.floor(num*dprec)/dprec
return np.round(num, dprec) Example 36
def sample_output(self, val):
vocabulary = self.get_vocabulary()
if self.one_hot:
vals = [ np.argmax(r) for r in val ]
ox_val = [vocabulary[obj] for obj in list(vals)]
string = "".join(ox_val)
return string
else:
val = np.reshape(val, [-1])
val *= len(vocabulary)/2.0
val += len(vocabulary)/2.0
val = np.round(val)
val = np.maximum(0, val)
val = np.minimum(len(vocabulary)-1, val)
ox_val = [self.get_character(obj) for obj in list(val)]
string = "".join(ox_val)
return string Example 37
def __init__(self, opt_engine, topK=16, grid_size=None, nps=320, model_name='tmp'):
QWidget.__init__(self)
self.topK = topK
if grid_size is None:
self.n_grid = int(np.ceil(np.sqrt(self.topK)))
self.grid_size = (self.n_grid, self.n_grid) # (width, height)
else:
self.grid_size = grid_size
self.select_id = 0
self.ims = None
self.vis_results = None
self.width = int(np.round(nps/ (4 * float(self.grid_size[1])))) * 4
self.winWidth = self.width * self.grid_size[0]
self.winHeight = self.width * self.grid_size[1]
self.setFixedSize(self.winWidth, self.winHeight)
self.opt_engine = opt_engine
self.frame_id = -1
self.sr = save_result.SaveResult(model_name=model_name) Example 38
def sresample(src, outshape):
""" Simple 3d array resampling
Inputs:
src -- a ndimensional array (dim>2)
outshape -- fixed output shape for the first 2 dimensions
Outputs:
hout -- resulting n-dimensional array
"""
inh, inw = src.shape[:2]
outh, outw = outshape
hslice = (np.arange(outh) * (inh-1.)/(outh-1.)).round().astype(int)
wslice = (np.arange(outw) * (inw-1.)/(outw-1.)).round().astype(int)
hout = src[hslice, :][:, wslice]
return hout.copy() Example 39
def stationInfo(stnds, varname, name, titlestr=None, alttitle=None, lflatten=False, lmon=False,):
''' helper to generate an axes title with station info '''
if stnds.hasAxis('station'): nstn = len(stnds.axes['station']) # number of stations
else: nstn = 1 # single station
if stnds.name[:3].lower() == 'obs' and varname in stnds:
ec = stnds[varname] # some variables are not present everywhere
if ec.hasAxis('time') and ec.time.units[:3].lower() == 'mon': units = 'mon.'
elif ec.hasAxis('year') and ec.year.units.lower() == 'year': units = 'yrs.'
else: units = 'mon.' if lmon else 'yrs.'
mask = ec.data_array.mask if isinstance(ec.data_array,np.ma.MaskedArray) else np.isnan(ec.data_array)
if lflatten: rec_len = (ec.data_array.size - mask.sum()) # valid years in obs/EC
else: rec_len = int(np.round(ec.data_array.shape[-1] - mask.sum(axis=-1).mean())) # valid years in obs/EC
if titlestr: axtitle = titlestr.format(name,nstn,rec_len) # axes label
else: axtitle = "{:s} (#{:d}, {:d} {:s})".format(name,nstn,rec_len,units) # axes label
else:
if alttitle: axtitle = alttitle.format(name,nstn) # axes label
elif titlestr: axtitle = titlestr.format(name,nstn) # axes label
else: axtitle = "{:s} (#{:d}, WRF only)".format(name,nstn) # axes label
return axtitle
# function to compute some statistics and print them Example 40
def get_fft_mel_mat(nfft, sr=8000, nfilts=None, width=1.0, minfrq=20, maxfrq=None, constamp=0):
if nfilts is None:
nfilts = nfft
if maxfrq is None:
maxfrq = sr // 2
wts = np.zeros((nfilts, nfft//2+1))
fftfrqs = np.arange(0, nfft//2+1) / (1. * nfft) * (sr)
minmel = hz2mel(minfrq)
maxmel = hz2mel(maxfrq)
binfrqs = mel2hz(minmel + np.arange(0, nfilts+2) / (nfilts+1.) * (maxmel - minmel))
# binbin = np.round(binfrqs / maxfrq * nfft)
for i in range(nfilts):
fs = binfrqs[[i+0, i+1, i+2]]
fs = fs[1] + width * (fs - fs[1])
loslope = (fftfrqs - fs[0]) / (fs[1] - fs[0])
hislope = (fs[2] - fftfrqs) / (fs[2] - fs[1])
wts[i, :] = np.maximum(0, np.minimum(loslope, hislope))
return wts Example 41
def get_fft_mel_mat(nfft, sr=8000, nfilts=None, width=1.0, minfrq=20, maxfrq=None, constamp=0):
if nfilts is None:
nfilts = nfft
if maxfrq is None:
maxfrq = sr // 2
wts = np.zeros((nfilts, nfft//2+1))
fftfrqs = np.arange(0, nfft//2+1) / (1. * nfft) * (sr)
minmel = hz2mel(minfrq)
maxmel = hz2mel(maxfrq)
binfrqs = mel2hz(minmel + np.arange(0, nfilts+2) / (nfilts+1.) * (maxmel - minmel))
# binbin = np.round(binfrqs / maxfrq * nfft)
for i in range(nfilts):
fs = binfrqs[[i+0, i+1, i+2]]
fs = fs[1] + width * (fs - fs[1])
loslope = (fftfrqs - fs[0]) / (fs[1] - fs[0])
hislope = (fs[2] - fftfrqs) / (fs[2] - fs[1])
wts[i, :] = np.maximum(0, np.minimum(loslope, hislope))
return wts Example 42
def CSMToBinary(D, Kappa):
"""
Turn a cross-similarity matrix into a binary cross-simlarity matrix
If Kappa = 0, take all neighbors
If Kappa < 1 it is the fraction of mutual neighbors to consider
Otherwise Kappa is the number of mutual neighbors to consider
"""
N = D.shape[0]
M = D.shape[1]
if Kappa == 0:
return np.ones((N, M))
elif Kappa < 1:
NNeighbs = int(np.round(Kappa*M))
else:
NNeighbs = Kappa
J = np.argpartition(D, NNeighbs, 1)[:, 0:NNeighbs]
I = np.tile(np.arange(N)[:, None], (1, NNeighbs))
V = np.ones(I.size)
[I, J] = [I.flatten(), J.flatten()]
ret = sparse.coo_matrix((V, (I, J)), shape=(N, M))
return ret.toarray() Example 43
def print_word_vectors(word_vectors, write_path):
"""
This function prints the collection of word vectors to file, in a plain textual format.
"""
f_write = codecs.open(write_path, 'w', 'utf-8')
for key in word_vectors:
print >>f_write, key, " ".join(map(unicode, numpy.round(word_vectors[key], decimals=6)))
print "Printed", len(word_vectors), "word vectors to:", write_path Example 44
def trataGroups(objeto):
current = list(filter(None.__ne__, objeto))
current = np.sort(current, axis=0)
for i in range(len(current[0])):
current_ = [j[i] for j in current]
mean_ = np.round(np.mean(current_, axis=0), 4)
deviation_ = np.round(np.std(current_, axis=0, ddof=1), 4)
return [mean_, deviation_] Example 45
def trataGroups(objeto):
current = list(filter(None.__ne__, objeto))
mean_ = np.round(np.mean(current, axis=0), 4)
deviation_ = np.round(np.std(current, axis=0, ddof=1), 4)
fivecent = np.round(np.percentile(current, 5.0, axis=0), 4)
# confidence intervals
lowci = np.round(np.percentile(current, 2.5, axis=0), 4)
highci = np.round(np.percentile(current, 97.5, axis=0), 4)
return [mean_, deviation_, fivecent, current, lowci, highci] Example 46
def PA(samples, variables):
datasets = 5000
eig_vals = []
for i in range(datasets):
data = np.random.standard_normal((variables, samples))
cor_ = np.corrcoef(data)
eig_vals.append(np.sort(np.linalg.eig(cor_)[0])[::-1])
quantile = (np.round(np.percentile(eig_vals, 95.0, axis=0), 4))
mean_ = (np.round(np.mean(eig_vals, axis=0), 4))
return quantile Example 47
def get_line_region(self, position, name=''):
"""Creates a line region at the given position (start_x, start_y, end_x, end_y),
inclusive.
Args:
position: Position of the line region (start_x, start_y, end_x, end_y).
name: Name of the region.
Returns:
Line region.
"""
start_idx = self.get_index(position[:2])
end_idx = self.get_index(position[2:])
x_diff = start_idx % self.x.samples - end_idx % self.x.samples
y_diff = int(start_idx / self.x.samples) - int(end_idx / self.x.samples)
num_points = max(np.abs([x_diff, y_diff]))
point_indices = []
for ii in range(num_points + 1):
x_position = start_idx % self.x.samples - np.round(ii / num_points * x_diff)
y_position = int(start_idx / self.x.samples) - np.round(ii / num_points * y_diff)
point_indices.append(int(x_position + self.x.samples * y_position))
return reg.LineRegion(point_indices, position, name=name) Example 48
def seq(start, stop, step=1): n = int(round((stop - start)/float(step))) if n > 1: return([start + step*i for i in range(n+1)]) else: return([])
Example 49
def draw_circles(image,cands,origin,spacing):
#make empty matrix, which will be filled with the mask
image_mask = np.zeros(image.shape, dtype=np.int16)
#run over all the nodules in the lungs
for ca in cands.values:
#get middel x-,y-, and z-worldcoordinate of the nodule
#radius = np.ceil(ca[4])/2 ## original: replaced the ceil with a very minor increase of 1% ....
radius = (ca[4])/2 + 0.51 * spacing[0] # increasing by circa half of distance in z direction .... (trying to capture wider region/border for learning ... and adress the rough net .
coord_x = ca[1]
coord_y = ca[2]
coord_z = ca[3]
image_coord = np.array((coord_z,coord_y,coord_x))
#determine voxel coordinate given the worldcoordinate
image_coord = world_2_voxel(image_coord,origin,spacing)
#determine the range of the nodule
#noduleRange = seq(-radius, radius, RESIZE_SPACING[0]) # original, uniform spacing
noduleRange_z = seq(-radius, radius, spacing[0])
noduleRange_y = seq(-radius, radius, spacing[1])
noduleRange_x = seq(-radius, radius, spacing[2])
#x = y = z = -2
#create the mask
for x in noduleRange_x:
for y in noduleRange_y:
for z in noduleRange_z:
coords = world_2_voxel(np.array((coord_z+z,coord_y+y,coord_x+x)),origin,spacing)
#if (np.linalg.norm(image_coord-coords) * RESIZE_SPACING[0]) < radius: ### original (contrained to a uniofrm RESIZE)
if (np.linalg.norm((image_coord-coords) * spacing)) < radius:
image_mask[int(np.round(coords[0])),int(np.round(coords[1])),int(np.round(coords[2]))] = int(1)
return image_mask Example 50
def seq(start, stop, step=1): n = int(round((stop - start)/float(step))) if n > 1: return([start + step*i for i in range(n+1)]) else: return([])
