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 _logcdf(self, samples):
lower = np.full(2, -np.inf)
upper = norm.ppf(samples)
limit_flags = np.zeros(2)
if upper.shape[0] > 0:
def func1d(upper1d):
'''
Calculates the multivariate normal cumulative distribution
function of a single sample.
'''
return mvn.mvndst(lower, upper1d, limit_flags, self.theta)[1]
vals = np.apply_along_axis(func1d, -1, upper)
else:
vals = np.empty((0, ))
old_settings = np.seterr(divide='ignore')
vals = np.log(vals)
np.seterr(**old_settings)
vals[np.any(samples == 0.0, axis=1)] = -np.inf
vals[samples[:, 0] == 1.0] = np.log(samples[samples[:, 0] == 1.0, 1])
vals[samples[:, 1] == 1.0] = np.log(samples[samples[:, 1] == 1.0, 0])
return vals Example 2
def _nanmedian(a, axis=None, out=None, overwrite_input=False):
"""
Private function that doesn't support extended axis or keepdims.
These methods are extended to this function using _ureduce
See nanmedian for parameter usage
"""
if axis is None or a.ndim == 1:
part = a.ravel()
if out is None:
return _nanmedian1d(part, overwrite_input)
else:
out[...] = _nanmedian1d(part, overwrite_input)
return out
else:
# for small medians use sort + indexing which is still faster than
# apply_along_axis
if a.shape[axis] < 400:
return _nanmedian_small(a, axis, out, overwrite_input)
result = np.apply_along_axis(_nanmedian1d, axis, a, overwrite_input)
if out is not None:
out[...] = result
return result Example 3
def _nanpercentile(a, q, axis=None, out=None, overwrite_input=False,
interpolation='linear', keepdims=False):
"""
Private function that doesn't support extended axis or keepdims.
These methods are extended to this function using _ureduce
See nanpercentile for parameter usage
"""
if axis is None:
part = a.ravel()
result = _nanpercentile1d(part, q, overwrite_input, interpolation)
else:
result = np.apply_along_axis(_nanpercentile1d, axis, a, q,
overwrite_input, interpolation)
# apply_along_axis fills in collapsed axis with results.
# Move that axis to the beginning to match percentile's
# convention.
if q.ndim != 0:
result = np.rollaxis(result, axis)
if out is not None:
out[...] = result
return result Example 4
def _fix_alpha_channel(self):
# This is a fix for a bug where the Alpha channel was dropped.
colors3to4 = [(c[:3], c[3]) for c in self.names.keys()]
colors3to4 = dict(colors3to4)
assert(len(colors3to4) == len(self.names)) # Dropped alpha channel causes colors to collide :(
for lbl in self.labels:
if lbl is None:
continue # No label file created yet.
img = Image.open(lbl)
size = img.size
img = np.array(img)
if img.shape[2] == 4:
continue # Image has alpha channel, good.
elif img.shape[2] == 3:
# Lookup each (partial) color and find what its alpha should be.
alpha = np.apply_along_axis(lambda c: colors3to4[tuple(c)], 2, img)
data = np.dstack([img, np.array(alpha, dtype=np.uint8)])
new_img = Image.frombuffer("RGBA", size, data, "raw", "RGBA", 0, 1)
new_img.save(lbl)
print("FIXED", lbl) Example 5
def plot_cost_to_go_mountain_car(env, estimator, num_tiles=20):
x = np.linspace(env.observation_space.low[0], env.observation_space.high[0], num=num_tiles)
y = np.linspace(env.observation_space.low[1], env.observation_space.high[1], num=num_tiles)
X, Y = np.meshgrid(x, y)
Z = np.apply_along_axis(lambda _: -np.max(estimator.predict(_)), 2, np.dstack([X, Y]))
fig = plt.figure(figsize=(10, 5))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
cmap=matplotlib.cm.coolwarm, vmin=-1.0, vmax=1.0)
ax.set_xlabel('Position')
ax.set_ylabel('Velocity')
ax.set_zlabel('Value')
ax.set_title("Mountain \"Cost To Go\" Function")
fig.colorbar(surf)
plt.show() Example 6
def boundary_tree_to_image(boundary_tree, size, image_mesh):
arr = array('B')
np.apply_along_axis(lambda c: arr.extend(boundary_tree.query(c)), 1, image_mesh)
return Image.frombytes("RGB", size, arr) Example 7
def __query_by_committee(self, clf, X_unlabeled):
num_classes = len(clf[0].classes_)
C = len(clf)
preds = []
if self.strategy == 'vote_entropy':
for model in clf:
y_out = map(int, model.predict(X_unlabeled))
preds.append(np.eye(num_classes)[y_out])
votes = np.apply_along_axis(np.sum, 0, np.stack(preds)) / C
return np.apply_along_axis(entropy, 1, votes)
elif self.strategy == 'average_kl_divergence':
for model in clf:
preds.append(model.predict_proba(X_unlabeled))
consensus = np.mean(np.stack(preds), axis=0)
divergence = []
for y_out in preds:
divergence.append(entropy(consensus.T, y_out.T))
return np.apply_along_axis(np.mean, 0, np.stack(divergence)) Example 8
def estimate_1hot_cost(X, is_categorical):
"""
Calculate the "memory expansion" after applying one-hot encoding.
:param X: array-like
The input data array
:param is_categorical: boolean array-like
Array of vector form that indicates
whether each features of X is categorical
:return: int
Calculated memory size in byte scale (expansion)
"""
n_columns = 0
count_labels_v = lambda v: np.sum(np.isfinite(np.unique(v))) - 1
n_labels = np.apply_along_axis(count_labels_v, 0, X)
n_columns += np.sum(n_labels[is_categorical])
estimated_memory = n_columns * X.shape[0] * X.dtype.itemsize
return estimated_memory Example 9
def load_dataset():
if(not os.path.exists("./dataset/training.csv")):
print("dataset does not exist")
raise Exception
#load dataset
labeled_image = pd.read_csv("./dataset/training.csv")
#preprocessing dataframe
image = np.array(labeled_image["Image"].values).reshape(-1,1)
image = np.apply_along_axis(lambda img: (img[0].split()),1,image)
image = image.astype(np.int32) #because train_img elements are string before preprocessing
image = image.reshape(-1,96*96) # data 96 * 96 size image
label = labeled_image.values[:,:-1]
label = label.astype(np.float32)
#nan value to mean value
col_mean = np.nanmean(label, axis=0)
indices = np.where(np.isnan(label))
label[indices] = np.take(col_mean, indices[1])
return image, label Example 10
def get_his_std_qi( data_pixel_qi, max_cts=None):
'''
YG. Dev 16, 2016
Calculate the photon histogram for one q by giving
Parameters:
data_pixel_qi: one-D array, for the photon counts
max_cts: for bin max, bin will be [0,1,2,..., max_cts]
Return:
bins
his
std
'''
if max_cts is None:
max_cts = np.max( data_pixel_qi ) +1
bins = np.arange(max_cts)
dqn, dqm = data_pixel_qi.shape
#get histogram here
H = np.apply_along_axis(np.bincount, 1, np.int_(data_pixel_qi), minlength= max_cts )/dqm
#do average for different frame
his = np.average( H, axis=0)
std = np.std( H, axis=0 )
#cal average photon counts
kmean= np.average(data_pixel_qi )
return bins, his, std, kmean Example 11
def _nanmedian(a, axis=None, out=None, overwrite_input=False):
"""
Private function that doesn't support extended axis or keepdims.
These methods are extended to this function using _ureduce
See nanmedian for parameter usage
"""
if axis is None or a.ndim == 1:
part = a.ravel()
if out is None:
return _nanmedian1d(part, overwrite_input)
else:
out[...] = _nanmedian1d(part, overwrite_input)
return out
else:
# for small medians use sort + indexing which is still faster than
# apply_along_axis
if a.shape[axis] < 400:
return _nanmedian_small(a, axis, out, overwrite_input)
result = np.apply_along_axis(_nanmedian1d, axis, a, overwrite_input)
if out is not None:
out[...] = result
return result Example 12
def _nanpercentile(a, q, axis=None, out=None, overwrite_input=False,
interpolation='linear', keepdims=False):
"""
Private function that doesn't support extended axis or keepdims.
These methods are extended to this function using _ureduce
See nanpercentile for parameter usage
"""
if axis is None:
part = a.ravel()
result = _nanpercentile1d(part, q, overwrite_input, interpolation)
else:
result = np.apply_along_axis(_nanpercentile1d, axis, a, q,
overwrite_input, interpolation)
# apply_along_axis fills in collapsed axis with results.
# Move that axis to the beginning to match percentile's
# convention.
if q.ndim != 0:
result = np.rollaxis(result, axis)
if out is not None:
out[...] = result
return result Example 13
def punion(probs, axis=None):
"""Find the unions of given list of probabilities assuming indepdendence.
Args:
probs: Matrix-like probabilities to union.
axis: Axis along which union will be performed.
Returns:
Matrix of probability unions.
"""
def punion1d(probs):
"""Union for 1d array.
"""
finalp = 0.0
for p in probs:
finalp += p*(1.0-finalp)
return finalp
probs = np.asarray(probs)
if axis is None:
return punion1d(probs.reshape((-1,)))
else:
return np.apply_along_axis(func1d=punion1d, axis=axis, arr=probs) Example 14
def addFamily(X):
# Family size: index 8
newCol = np.array(X[:, 1] + X[:, 2], np.newaxis)
newCol = newCol.reshape((len(newCol), 1))
X = np.hstack( (X,newCol) )
# Family category: index 9
def determineFamilyCat(row):
# print('row shape = {}, cont = {}'.format(row.shape, row))
if row[8] == 1:
return 0 # singles
elif 2<=row[8]<=4:
return 1 # normal size
else:
return 2 # large size
newCol = np.apply_along_axis(determineFamilyCat, 1, X)
newCol = newCol.reshape((len(newCol), 1))
X = np.hstack((X,newCol))
return X
# Not used Example 15
def update_recover_maps(self):
max_distance = min(self.width // 2, self.height // 2, 15)
#self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
#self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
#self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
#self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
#self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
#self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 16
def update_recover_maps(self):
max_distance = min(self.width // 2, self.height // 2, 15)
#self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
#self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
#self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
#self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
#self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
#self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 17
def update_recover_maps(self):
max_distance = min(self.width // 2, self.height // 2, 15)
#self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
#self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
#self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
#self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
#self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
#self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 18
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 19
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 20
def update_recover_maps(self):
max_distance = min(self.width // 2, self.height // 2, 15)
#self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
#self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
#self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
#self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
#self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
#self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 21
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 22
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 23
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 24
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 25
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 26
def update_recover_maps(self):
max_distance = self.width // 2
self.recover_map = np.zeros((max_distance + 1, self.width, self.height))
self.recover_map[0] = np.divide(self.strength_map, self.production_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map = np.zeros((max_distance + 1, self.width, self.height))
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
new_str_map = np.copy(self.strength_map)
new_str_map[new_str_map == 0] = 2
#self.prod_over_str_map[0] = np.divide(self.production_map, self.strength_map_01) * (self.is_neutral_map - self.combat_zone_map)
self.prod_over_str_map[0] = np.divide(self.production_map, new_str_map) * (self.is_neutral_map - self.combat_zone_map)
self.recover_map[0] = 1 / np.maximum(self.prod_over_str_map[0], 0.01)
for distance in range(1, max_distance + 1):
self.prod_over_str_map[distance] = spread_n(self.prod_over_str_map[distance - 1], 1)
self.prod_over_str_map[distance][self.prod_over_str_map[distance-1] == 0] = 0
self.prod_over_str_map[distance] = self.prod_over_str_map[distance] / 5
self.recover_map[distance] = 1 / np.maximum(self.prod_over_str_map[distance], 0.01)
self.prod_over_str_max_map = np.apply_along_axis(np.max, 0, self.prod_over_str_map)
self.recover_max_map = 1 / np.maximum(self.prod_over_str_max_map, 0.01)
self.prod_over_str_avg_map = np.apply_along_axis(np.mean, 0, self.prod_over_str_map)
self.recover_avg_map = 1 / np.maximum(self.prod_over_str_avg_map, 0.01)
self.prod_over_str_wtd_map = (self.prod_over_str_max_map + self.prod_over_str_avg_map) / 2
self.recover_wtd_map = 1 / np.maximum(self.prod_over_str_wtd_map, 0.01) Example 27
def match_matrix(event: Event):
"""Returns a numpy participation matrix for the qualification matches in this event, used for calculating OPR.
Each row in the matrix corresponds to a single alliance in a match, meaning that there will be two rows (one for
red, one for blue) per match. Each column represents a single team, ordered by team number. If a team participated
on a certain alliance, the value at that row and column would be 1, otherwise, it would be 0. For example, an
event with teams 1-7 that featured a match that pitted teams 1, 3, and 5 against 2, 4, and 6 would have a match
matrix that looks like this (sans labels):
#1 #2 #3 #4 #5 #6 #7
qm1_red 1 0 1 0 1 0 0
qm1_blue 0 1 0 1 0 1 0
"""
match_list = []
for match in filter(lambda match: match['comp_level'] == 'qm', event.matches):
matchRow = []
for team in event.teams:
matchRow.append(1 if team['key'] in match['alliances']['red']['teams'] else 0)
match_list.append(matchRow)
matchRow = []
for team in event.teams:
matchRow.append(1 if team['key'] in match['alliances']['blue']['teams'] else 0)
match_list.append(matchRow)
mat = numpy.array(match_list)
sum_matches = numpy.sum(mat, axis=0)
avg_team_matches = sum(sum_matches) / float(len(sum_matches))
return mat[:, numpy.apply_along_axis(numpy.count_nonzero, 0, mat) > avg_team_matches - 2] Example 28
def cluster_words(words, service_name, size):
stopwords = ["GET", "POST", "total", "http-requests", service_name, "-", "_"]
cleaned_words = []
for word in words:
for stopword in stopwords:
word = word.replace(stopword, "")
cleaned_words.append(word)
def distance(coord):
i, j = coord
return 1 - jaro_distance(cleaned_words[i], cleaned_words[j])
indices = np.triu_indices(len(words), 1)
distances = np.apply_along_axis(distance, 0, indices)
return cluster_of_size(linkage(distances), size) Example 29
def permute_rows(seed, array):
"""
Shuffle each row in ``array`` based on permutations generated by ``seed``.
Parameters
----------
seed : int
Seed for numpy.RandomState
array : np.ndarray[ndim=2]
Array over which to apply permutations.
"""
rand = np.random.RandomState(seed)
return np.apply_along_axis(rand.permutation, 1, array) Example 30
def __detect_now(self,spike_waveforms,selectChan,current_page):
if selectChan+"_"+str(current_page) in self.windowsState:
use_shape0 = self.__pk0_roi0_pos(selectChan,current_page)
spk_in_line = np.apply_along_axis(self.__in_select_line,1,spike_waveforms,use_shape0[0],use_shape0[1])
use_shape1 = self.__pk0_roi1_pos(selectChan,current_page)
spk_in_line1 = np.apply_along_axis(self.__in_select_line,1,spike_waveforms,use_shape1[0],use_shape1[1])
detected_mask = spk_in_line & spk_in_line1
else:
detected_mask = np.ones(spike_waveforms.shape[0],dtype=bool)
return detected_mask
# check whether a spike's waveform is intersect with segment widget Example 31
def __in_select_line(self,temp_spike,pos_1,pos_2):
pos_3y = temp_spike[:-1]
pos_3x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(pos_3y.shape[0])
pos_4y = temp_spike[1:]
pos_4x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(1,pos_3y.shape[0]+1)
pos_3_4 = np.vstack([ pos_3x,pos_3y,pos_4x,pos_4y]).T
is_insect = np.apply_along_axis(self.__intersect,1,pos_3_4,pos_1,pos_2)
return np.any(is_insect) Example 32
def __indexs_select_pk0(self,pk0_roi0_h0,pk0_roi0_h1,pk0_roi1_h0,pk0_roi1_h1):
# get indexs of selected waveforms in pk0
spk_in_line = np.apply_along_axis(self.__in_select_line,1,self.waveforms_pk0,pk0_roi0_h0,pk0_roi0_h1)
changed_index = np.where(spk_in_line==True)[0]
changed_index = np.array(changed_index,dtype=np.int32)
spk_in_line1 = np.apply_along_axis(self.__in_select_line,1,self.waveforms_pk0,pk0_roi1_h0,pk0_roi1_h1)
changed_index1 = np.where(spk_in_line1==True)[0]
changed_index1 = np.array(changed_index1,dtype=np.int32)
changed_index = np.intersect1d(changed_index, changed_index1)
return changed_index + self.indexs_pk0[0] Example 33
def __in_select_line(self,temp_spike,pos_1,pos_2):
pos_3y = temp_spike[:-1]
pos_3x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(pos_3y.shape[0])
pos_4y = temp_spike[1:]
pos_4x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(1,pos_3y.shape[0]+1)
pos_3_4 = np.vstack([ pos_3x,pos_3y,pos_4x,pos_4y]).T
is_insect = np.apply_along_axis(self.__intersect,1,pos_3_4,pos_1,pos_2)
return np.any(is_insect) Example 34
def __indexs_select_pk2(self,pk2_roi_pos):
x_min = pk2_roi_pos[:,0].min()
x_max = pk2_roi_pos[:,0].max()
y_min = pk2_roi_pos[:,1].min()
y_max = pk2_roi_pos[:,1].max()
pca_1,pca_2 = self.PCAusedList.currentText().split("-")
pca_1 = np.int(pca_1)-1
pca_2 = np.int(pca_2)-1
x = np.logical_and(self.wavePCAs[:,pca_1]>x_min, \
self.wavePCAs[:,pca_1]<x_max)
y = np.logical_and(self.wavePCAs[:,pca_2]>y_min, \
self.wavePCAs[:,pca_2]<y_max)
ind_0 = np.logical_and(x, y)
ind_0 = np.where(ind_0 == True)[0]
ind_0 = np.array(ind_0,dtype=np.int32)
if ind_0.shape[0]>0:
segments = []
for i in range(pk2_roi_pos.shape[0]-1):
segments.append([pk2_roi_pos[i],pk2_roi_pos[i+1]])
segments.append([pk2_roi_pos[-1],pk2_roi_pos[0]])
segments = np.array(segments)
temp_pcas = self.wavePCAs[ind_0]
temp_pcas = temp_pcas[:,[pca_1,pca_2]]
is_intersect = np.apply_along_axis(self.__intersect_roi2,1,temp_pcas,segments,pca_1)
return ind_0[is_intersect]
else:
return np.array([],dtype=np.int32) Example 35
def __detect_now(self,spike_waveforms,selectChan,current_page):
if selectChan+"_"+str(current_page) in self.windowsState:
use_shape0 = self.__pk0_roi0_pos(selectChan,current_page)
spk_in_line = np.apply_along_axis(self.__in_select_line,1,spike_waveforms,use_shape0[0],use_shape0[1])
use_shape1 = self.__pk0_roi1_pos(selectChan,current_page)
spk_in_line1 = np.apply_along_axis(self.__in_select_line,1,spike_waveforms,use_shape1[0],use_shape1[1])
detected_mask = spk_in_line & spk_in_line1
else:
detected_mask = np.ones(spike_waveforms.shape[0],dtype=bool)
return detected_mask
# check whether a spike's waveform is intersect with segment widget Example 36
def __in_select_line(self,temp_spike,pos_1,pos_2):
pos_3y = temp_spike[:-1]
pos_3x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(pos_3y.shape[0])
pos_4y = temp_spike[1:]
pos_4x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(1,pos_3y.shape[0]+1)
pos_3_4 = np.vstack([ pos_3x,pos_3y,pos_4x,pos_4y]).T
is_insect = np.apply_along_axis(self.__intersect,1,pos_3_4,pos_1,pos_2)
return np.any(is_insect) Example 37
def __indexs_select_pk0(self,pk0_roi0_h0,pk0_roi0_h1,pk0_roi1_h0,pk0_roi1_h1):
# get indexs of selected waveforms in pk0
spk_in_line = np.apply_along_axis(self.__in_select_line,1,self.waveforms_pk0,pk0_roi0_h0,pk0_roi0_h1)
changed_index = np.where(spk_in_line==True)[0]
changed_index = np.array(changed_index,dtype=np.int32)
spk_in_line1 = np.apply_along_axis(self.__in_select_line,1,self.waveforms_pk0,pk0_roi1_h0,pk0_roi1_h1)
changed_index1 = np.where(spk_in_line1==True)[0]
changed_index1 = np.array(changed_index1,dtype=np.int32)
changed_index = np.intersect1d(changed_index, changed_index1)
return changed_index + self.indexs_pk0[0] Example 38
def __in_select_line(self,temp_spike,pos_1,pos_2):
pos_3y = temp_spike[:-1]
pos_3x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(pos_3y.shape[0])
pos_4y = temp_spike[1:]
pos_4x = np.ones(pos_3y.shape,dtype=np.int32)*np.arange(1,pos_3y.shape[0]+1)
pos_3_4 = np.vstack([ pos_3x,pos_3y,pos_4x,pos_4y]).T
is_insect = np.apply_along_axis(self.__intersect,1,pos_3_4,pos_1,pos_2)
return np.any(is_insect) Example 39
def __indexs_select_pk2(self,pk2_roi_pos):
x_min = pk2_roi_pos[:,0].min()
x_max = pk2_roi_pos[:,0].max()
y_min = pk2_roi_pos[:,1].min()
y_max = pk2_roi_pos[:,1].max()
pca_1,pca_2 = self.PCAusedList.currentText().split("-")
pca_1 = np.int(pca_1)-1
pca_2 = np.int(pca_2)-1
x = np.logical_and(self.wavePCAs[:,pca_1]>x_min, \
self.wavePCAs[:,pca_1]<x_max)
y = np.logical_and(self.wavePCAs[:,pca_2]>y_min, \
self.wavePCAs[:,pca_2]<y_max)
ind_0 = np.logical_and(x, y)
ind_0 = np.where(ind_0 == True)[0]
ind_0 = np.array(ind_0,dtype=np.int32)
if ind_0.shape[0]>0:
segments = []
for i in range(pk2_roi_pos.shape[0]-1):
segments.append([pk2_roi_pos[i],pk2_roi_pos[i+1]])
segments.append([pk2_roi_pos[-1],pk2_roi_pos[0]])
segments = np.array(segments)
temp_pcas = self.wavePCAs[ind_0]
temp_pcas = temp_pcas[:,[pca_1,pca_2]]
is_intersect = np.apply_along_axis(self.__intersect_roi2,1,temp_pcas,segments,pca_1)
return ind_0[is_intersect]
else:
return np.array([],dtype=np.int32) Example 40
def normalize_simple(matrix, mask):
"""Normalizes a matrix by columns, and then by rows. With multiple
time-series, the data are normalized to the within-series total, not the
entire data set total.
Parameters
----------
matrix: np.matrix
Time-series matrix of abundance counts. Rows are sequences, columns
are samples/time-points.
mask: list or np.array
List of objects with length matching the number of timepoints, where
unique values delineate multiple time-series. If there is only one
time-series in the data set, it's a list of identical objects.
Returns
-------
normal_matrix: np.matrix
Matrix where the columns (within-sample) have been converted to
proportions, then the rows are normalized to sum to 1.
"""
normal_matrix = matrix / matrix.sum(0)
normal_matrix[np.invert(np.isfinite(normal_matrix))] = 0
for mask_val in np.unique(mask):
y = normal_matrix[:, np.where(mask == mask_val)[0]]
y = np.apply_along_axis(zscore, 1, y)
normal_matrix[:, np.where(mask == mask_val)[0]] = y
del y
return normal_matrix Example 41
def feat_eeg(signals):
"""
calculate the relative power as defined by Leangkvist (2012),
assuming signal is recorded with 100hz
"""
if signals.ndim == 1: signals = np.expand_dims(signals,0)
sfreq = use_sfreq
nsamp = float(signals.shape[1])
feats = np.zeros((signals.shape[0],9),dtype='float32')
# 5 FEATURE for freq babnds
w = (fft(signals,axis=1)).real
delta = np.sum(np.abs(w[:,np.arange(0.5*nsamp/sfreq,4*nsamp/sfreq, dtype=int)]),axis=1)
theta = np.sum(np.abs(w[:,np.arange(4*nsamp/sfreq,8*nsamp/sfreq, dtype=int)]),axis=1)
alpha = np.sum(np.abs(w[:,np.arange(8*nsamp/sfreq,13*nsamp/sfreq, dtype=int)]),axis=1)
beta = np.sum(np.abs(w[:,np.arange(13*nsamp/sfreq,20*nsamp/sfreq, dtype=int)]),axis=1)
gamma = np.sum(np.abs(w[:,np.arange(20*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]),axis=1) # only until 50, because hz=100
spindle = np.sum(np.abs(w[:,np.arange(12*nsamp/sfreq,14*nsamp/sfreq, dtype=int)]),axis=1)
sum_abs_pow = delta + theta + alpha + beta + gamma + spindle
feats[:,0] = delta /sum_abs_pow
feats[:,1] = theta /sum_abs_pow
feats[:,2] = alpha /sum_abs_pow
feats[:,3] = beta /sum_abs_pow
feats[:,4] = gamma /sum_abs_pow
feats[:,5] = spindle /sum_abs_pow
feats[:,6] = np.log10(stats.kurtosis(signals, fisher=False, axis=1)) # kurtosis
feats[:,7] = np.log10(-np.sum([(x/nsamp)*(np.log(x/nsamp)) for x in np.apply_along_axis(lambda x: np.histogram(x, bins=8)[0], 1, signals)],axis=1)) # entropy.. yay, one line...
#feats[:,7] = np.polynomial.polynomial.polyfit(np.log(f[np.arange(0.5*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]), np.log(w[0,np.arange(0.5*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]),1)
feats[:,8] = np.dot(np.array([3.5,4,5,7,30]),feats[:,0:5].T ) / (sfreq/2-0.5)
if np.any(feats==np.nan): print('NaN detected')
return np.nan_to_num(feats) Example 42
def feat_wavelet(signals):
"""
calculate the relative power as defined by Leangkvist (2012),
assuming signal is recorded with 100hz
"""
if signals.ndim == 1: signals = np.expand_dims(signals,0)
sfreq = use_sfreq
nsamp = float(signals.shape[1])
feats = np.zeros((signals.shape[0],8),dtype='float32')
# 5 FEATURE for freq babnds
w = (fft(signals,axis=1)).real
delta = np.sum(np.abs(w[:,np.arange(0.5*nsamp/sfreq,4*nsamp/sfreq, dtype=int)]),axis=1)
theta = np.sum(np.abs(w[:,np.arange(4*nsamp/sfreq,8*nsamp/sfreq, dtype=int)]),axis=1)
alpha = np.sum(np.abs(w[:,np.arange(8*nsamp/sfreq,13*nsamp/sfreq, dtype=int)]),axis=1)
beta = np.sum(np.abs(w[:,np.arange(13*nsamp/sfreq,20*nsamp/sfreq, dtype=int)]),axis=1)
gamma = np.sum(np.abs(w[:,np.arange(20*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]),axis=1) # only until 50, because hz=100
sum_abs_pow = delta + theta + alpha + beta + gamma
feats[:,0] = delta /sum_abs_pow
feats[:,1] = theta /sum_abs_pow
feats[:,2] = alpha /sum_abs_pow
feats[:,3] = beta /sum_abs_pow
feats[:,4] = gamma /sum_abs_pow
feats[:,5] = np.log10(stats.kurtosis(signals,fisher=False,axis=1)) # kurtosis
feats[:,6] = np.log10(-np.sum([(x/nsamp)*(np.log(x/nsamp)) for x in np.apply_along_axis(lambda x: np.histogram(x, bins=8)[0], 1, signals)],axis=1)) # entropy.. yay, one line...
#feats[:,7] = np.polynomial.polynomial.polyfit(np.log(f[np.arange(0.5*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]), np.log(w[0,np.arange(0.5*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]),1)
feats[:,7] = np.dot(np.array([3.5,4,5,7,30]),feats[:,0:5].T ) / (sfreq/2-0.5)
if np.any(feats==np.nan): print('NaN detected')
return np.nan_to_num(feats) Example 43
def feat_eog(signals):
"""
calculate the EOG features
:param signals: 1D or 2D signals
"""
if signals.ndim == 1: signals = np.expand_dims(signals,0)
sfreq = use_sfreq
nsamp = float(signals.shape[1])
w = (fft(signals,axis=1)).real
feats = np.zeros((signals.shape[0],15),dtype='float32')
delta = np.sum(np.abs(w[:,np.arange(0.5*nsamp/sfreq,4*nsamp/sfreq, dtype=int)]),axis=1)
theta = np.sum(np.abs(w[:,np.arange(4*nsamp/sfreq,8*nsamp/sfreq, dtype=int)]),axis=1)
alpha = np.sum(np.abs(w[:,np.arange(8*nsamp/sfreq,13*nsamp/sfreq, dtype=int)]),axis=1)
beta = np.sum(np.abs(w[:,np.arange(13*nsamp/sfreq,20*nsamp/sfreq, dtype=int)]),axis=1)
gamma = np.sum(np.abs(w[:,np.arange(20*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]),axis=1) # only until 50, because hz=100
sum_abs_pow = delta + theta + alpha + beta + gamma
feats[:,0] = delta /sum_abs_pow
feats[:,1] = theta /sum_abs_pow
feats[:,2] = alpha /sum_abs_pow
feats[:,3] = beta /sum_abs_pow
feats[:,4] = gamma /sum_abs_pow
feats[:,5] = np.dot(np.array([3.5,4,5,7,30]),feats[:,0:5].T ) / (sfreq/2-0.5) #smean
feats[:,6] = np.sqrt(np.max(signals, axis=1)) #PAV
feats[:,7] = np.sqrt(np.abs(np.min(signals, axis=1))) #VAV
feats[:,8] = np.argmax(signals, axis=1)/nsamp #PAP
feats[:,9] = np.argmin(signals, axis=1)/nsamp #VAP
feats[:,10] = np.sqrt(np.sum(np.abs(signals), axis=1)/ np.mean(np.sum(np.abs(signals), axis=1))) # AUC
feats[:,11] = np.sum(((np.roll(np.sign(signals), 1,axis=1) - np.sign(signals)) != 0).astype(int),axis=1)/nsamp #TVC
feats[:,12] = np.log10(np.std(signals, axis=1)) #STD/VAR
feats[:,13] = np.log10(stats.kurtosis(signals,fisher=False,axis=1)) # kurtosis
feats[:,14] = np.log10(-np.sum([(x/nsamp)*((np.log((x+np.spacing(1))/nsamp))) for x in np.apply_along_axis(lambda x: np.histogram(x, bins=8)[0], 1, signals)],axis=1)) # entropy.. yay, one line...
if np.any(feats==np.nan): print('NaN detected')
return np.nan_to_num(feats) Example 44
def feat_emg(signals):
"""
calculate the EMG median as defined by Leangkvist (2012),
"""
if signals.ndim == 1: signals = np.expand_dims(signals,0)
sfreq = use_sfreq
nsamp = float(signals.shape[1])
w = (fft(signals,axis=1)).real
feats = np.zeros((signals.shape[0],13),dtype='float32')
delta = np.sum(np.abs(w[:,np.arange(0.5*nsamp/sfreq,4*nsamp/sfreq, dtype=int)]),axis=1)
theta = np.sum(np.abs(w[:,np.arange(4*nsamp/sfreq,8*nsamp/sfreq, dtype=int)]),axis=1)
alpha = np.sum(np.abs(w[:,np.arange(8*nsamp/sfreq,13*nsamp/sfreq, dtype=int)]),axis=1)
beta = np.sum(np.abs(w[:,np.arange(13*nsamp/sfreq,20*nsamp/sfreq, dtype=int)]),axis=1)
gamma = np.sum(np.abs(w[:,np.arange(20*nsamp/sfreq,50*nsamp/sfreq, dtype=int)]),axis=1) # only until 50, because hz=100
sum_abs_pow = delta + theta + alpha + beta + gamma
feats[:,0] = delta /sum_abs_pow
feats[:,1] = theta /sum_abs_pow
feats[:,2] = alpha /sum_abs_pow
feats[:,3] = beta /sum_abs_pow
feats[:,4] = gamma /sum_abs_pow
feats[:,5] = np.dot(np.array([3.5,4,5,7,30]),feats[:,0:5].T ) / (sfreq/2-0.5) #smean
emg = np.sum(np.abs(w[:,np.arange(12.5*nsamp/sfreq,32*nsamp/sfreq, dtype=int)]),axis=1)
feats[:,6] = emg / np.sum(np.abs(w[:,np.arange(8*nsamp/sfreq,32*nsamp/sfreq, dtype=int)]),axis=1) # ratio of high freq to total motor
feats[:,7] = np.median(np.abs(w[:,np.arange(8*nsamp/sfreq,32*nsamp/sfreq, dtype=int)]),axis=1) # median freq
feats[:,8] = np.mean(np.abs(w[:,np.arange(8*nsamp/sfreq,32*nsamp/sfreq, dtype=int)]),axis=1) # mean freq
feats[:,9] = np.std(signals, axis=1) # std
feats[:,10] = np.mean(signals,axis=1)
feats[:,11] = np.log10(stats.kurtosis(signals,fisher=False,axis=1) )
feats[:,12] = np.log10(-np.sum([(x/nsamp)*((np.log((x+np.spacing(1))/nsamp))) for x in np.apply_along_axis(lambda x: np.histogram(x, bins=8)[0], 1, signals)],axis=1)) # entropy.. yay, one line...
if np.any(feats==np.nan): print('NaN detected')
return np.nan_to_num(feats) Example 45
def jaccard(inclusion):
"""Calculate jaccard distances for a community."""
logger.info("calculating jaccard distance for {}x{} input matrix".format(
*inclusion.shape))
jaccard = np.apply_along_axis(
lambda a: (a & inclusion).sum(1), 1, inclusion)
jaccard = jaccard / np.apply_along_axis(
lambda a: (a | inclusion).sum(1), 1, inclusion)
return 1 - jaccard Example 46
def euclidean(inclusion):
"""Calculate euclidean distances for a community."""
logger.info("calculating euclidean distance for {}x{} input matrix".format(
*inclusion.shape))
euclidean = np.apply_along_axis(
lambda a: ((a - inclusion) ** 2).sum(1), 1, inclusion)
return np.sqrt(euclidean) Example 47
def calc_pairwise_cosine(model):
n = model.num_topics
weights = model.state.get_lambda()
weights = np.apply_along_axis(lambda x: x / x.sum(), 1, weights) # get dist.
weights = unitmatrix(weights) # normalize
score = []
for i in range(n):
for j in range(i + 1, n):
score.append(np.arccos(weights[i].dot(weights[j])))
return np.mean(score), np.std(score) Example 48
def calc_pairwise_dev(model):
# the average squared deviation from 0 (90 degree)
n = model.num_topics
weights = model.state.get_lambda()
weights = np.apply_along_axis(lambda x: x / x.sum(), 1, weights) # get dist.
weights = unitmatrix(weights) # normalize
score = 0.
for i in range(n):
for j in range(i + 1, n):
score += (weights[i].dot(weights[j]))**2
return np.sqrt(2. * score / n / (n - 1)) Example 49
def decode(self, X, mode='argmax'):
if mode == 'argmax':
X = X.argmax(axis=-1)
elif mode == 'choice':
X = np.apply_along_axis(lambda vec: \
np.random.choice(len(vec), 1,
p=(vec / np.sum(vec))),
axis=-1, arr=X).ravel()
return str.join('',(self.indices_char[x] for x in X)) Example 50
def _nanmedian_small(a, axis=None, out=None, overwrite_input=False):
"""
sort + indexing median, faster for small medians along multiple
dimensions due to the high overhead of apply_along_axis
see nanmedian for parameter usage
"""
a = np.ma.masked_array(a, np.isnan(a))
m = np.ma.median(a, axis=axis, overwrite_input=overwrite_input)
for i in range(np.count_nonzero(m.mask.ravel())):
warnings.warn("All-NaN slice encountered", RuntimeWarning)
if out is not None:
out[...] = m.filled(np.nan)
return out
return m.filled(np.nan) 