Python numpy 模块，ndenumerate() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用numpy.ndenumerate()。
def saveHintonPlot(self, matrix, num_tests, max_weight=None, ax=None):
"""Draw Hinton diagram for visualizing a weight matrix."""
fig,ax = plt.subplots(1,1)
if not max_weight:
max_weight = 2**np.ceil(np.log(np.abs(matrix).max())/np.log(2))
ax.patch.set_facecolor('gray')
ax.set_aspect('equal', 'box')
ax.xaxis.set_major_locator(plt.NullLocator())
ax.yaxis.set_major_locator(plt.NullLocator())
for (x, y), w in np.ndenumerate(matrix):
color = 'white' if w > 0 else 'black'
size = np.sqrt(np.abs(0.5*w/num_tests)) # Need to scale so that it is between 0 and 0.5
rect = plt.Rectangle([x - size / 2, y - size / 2], size, size,
facecolor=color, edgecolor=color)
ax.add_patch(rect)
ax.autoscale_view()
ax.invert_yaxis()
plt.savefig(self.figures_path + self.save_prefix + '-Hinton.eps')
plt.close()
def cal_hist(self, t1, t2, data1_maxlen, hist_size):
mhist = np.zeros((data1_maxlen, hist_size), dtype=np.float32)
d1len = len(self.data1[t1])
if self.use_hist_feats:
assert (t1, t2) in self.hist_feats
caled_hist = np.reshape(self.hist_feats[(t1, t2)], (d1len, hist_size))
if d1len < data1_maxlen:
mhist[:d1len, :] = caled_hist[:, :]
else:
mhist[:, :] = caled_hist[:data1_maxlen, :]
else:
t1_rep = self.embed[self.data1[t1]]
t2_rep = self.embed[self.data2[t2]]
mm = t1_rep.dot(np.transpose(t2_rep))
for (i,j), v in np.ndenumerate(mm):
if i >= data1_maxlen:
break
vid = int((v + 1.) / 2. * ( hist_size - 1.))
mhist[i][vid] += 1.
mhist += 1.
mhist = np.log10(mhist)
return mhist
def cal_hist(self, t1, t2, data1_maxlen, hist_size):
mhist = np.zeros((data1_maxlen, hist_size), dtype=np.float32)
t1_cont = list(self.data1[t1])
t2_cont = list(self.data2[t2])
d1len = len(t1_cont)
if self.use_hist_feats:
assert (t1, t2) in self.hist_feats
caled_hist = np.reshape(self.hist_feats[(t1, t2)], (d1len, hist_size))
if d1len < data1_maxlen:
mhist[:d1len, :] = caled_hist[:, :]
else:
mhist[:, :] = caled_hist[:data1_maxlen, :]
else:
t1_rep = self.embed[t1_cont]
t2_rep = self.embed[t2_cont]
mm = t1_rep.dot(np.transpose(t2_rep))
for (i,j), v in np.ndenumerate(mm):
if i >= data1_maxlen:
break
vid = int((v + 1.) / 2. * ( hist_size - 1.))
mhist[i][vid] += 1.
mhist += 1.
mhist = np.log10(mhist)
return mhist
def cal_hist(self, t1, t2, data1_maxlen, hist_size):
mhist = np.zeros((data1_maxlen, hist_size), dtype=np.float32)
t1_cont = list(self.data1[t1])
t2_cont = list(self.data2[t2])
d1len = len(t1_cont)
if self.use_hist_feats:
assert (t1, t2) in self.hist_feats
curr_pair_feats = list(self.hist_feats[(t1, t2)])
caled_hist = np.reshape(curr_pair_feats, (d1len, hist_size))
if d1len < data1_maxlen:
mhist[:d1len, :] = caled_hist[:, :]
else:
mhist[:, :] = caled_hist[:data1_maxlen, :]
else:
t1_rep = self.embed[t1_cont]
t2_rep = self.embed[t2_cont]
mm = t1_rep.dot(np.transpose(t2_rep))
for (i,j), v in np.ndenumerate(mm):
if i >= data1_maxlen:
break
vid = int((v + 1.) / 2. * ( hist_size - 1.))
mhist[i][vid] += 1.
mhist += 1.
mhist = np.log10(mhist)
return mhist
def cal_hist(self, t1, t2, data1_maxlen, hist_size):
mhist = np.zeros((data1_maxlen, hist_size), dtype=np.float32)
t1_cont = list(self.data1[t1])
t2_cont = list(self.data2[t2])
d1len = len(t1_cont)
if self.use_hist_feats:
assert (t1, t2) in self.hist_feats
caled_hist = np.reshape(self.hist_feats[(t1, t2)], (d1len, hist_size))
if d1len < data1_maxlen:
mhist[:d1len, :] = caled_hist[:, :]
else:
mhist[:, :] = caled_hist[:data1_maxlen, :]
else:
t1_rep = self.embed[t1_cont]
t2_rep = self.embed[t2_cont]
mm = t1_rep.dot(np.transpose(t2_rep))
for (i,j), v in np.ndenumerate(mm):
if i >= data1_maxlen:
break
vid = int((v + 1.) / 2. * ( hist_size - 1.))
mhist[i][vid] += 1.
mhist += 1.
mhist = np.log10(mhist)
return mhist
def cal_hist(self, t1, t2, data1_maxlen, hist_size):
mhist = np.zeros((data1_maxlen, hist_size), dtype=np.float32)
t1_cont = list(self.data1[t1])
t2_cont = list(self.data2[t2])
d1len = len(t1_cont)
if self.use_hist_feats:
assert (t1, t2) in self.hist_feats
curr_pair_feats = list(self.hist_feats[(t1, t2)])
caled_hist = np.reshape(curr_pair_feats, (d1len, hist_size))
if d1len < data1_maxlen:
mhist[:d1len, :] = caled_hist[:, :]
else:
mhist[:, :] = caled_hist[:data1_maxlen, :]
else:
t1_rep = self.embed[t1_cont]
t2_rep = self.embed[t2_cont]
mm = t1_rep.dot(np.transpose(t2_rep))
for (i,j), v in np.ndenumerate(mm):
if i >= data1_maxlen:
break
vid = int((v + 1.) / 2. * ( hist_size - 1.))
mhist[i][vid] += 1.
mhist += 1.
mhist = np.log10(mhist)
return mhist
def write_pml_elems(sorted_pml_elems, pmlfile="elems_pml.dyn"):
"""Create a new elements file that the PML elements.
:param sorted_pml_elems:
:param pmlfile: default = elems_pml.dyn
:returns:
"""
from numpy import ndenumerate
pml = open(pmlfile, 'w')
pml.write('$ PML elements generated by bc.py\n')
pml.write('*ELEMENT_SOLID\n')
for i, e in ndenumerate(sorted_pml_elems):
pml.write('%i,%i,%i,%i,%i,%i,%i,%i,%i,%i\n' % (e['id'], e['pid'],
e['n1'], e['n2'],
e['n3'], e['n4'],
e['n5'], e['n6'],
e['n7'], e['n8']))
pml.write('*END\n')
pml.close()
return 0
def generate_data(sample_size=200, pd=[[0.4, 0.4], [0.1, 0.1]]):
pd = np.array(pd)
pd /= pd.sum()
offset = 50
bins = np.r_[np.zeros((1,)), np.cumsum(pd)]
bin_counts = np.histogram(np.random.rand(sample_size), bins)[0]
data = np.empty((0, 2))
targets = []
for ((i, j), p), count in zip(np.ndenumerate(pd), bin_counts):
xs = np.random.uniform(low=0.0, high=50.0, size=count) + j * offset
ys = np.random.uniform(low=0.0, high=50.0, size=count) + -i * offset
data = np.vstack((data, np.c_[xs, ys]))
if i == j:
targets.extend([1] * count)
else:
targets.extend([-1] * count)
return np.c_[data, targets]
def finite_diff_gradients(self, f, delta=1e-6):
"""
f is called without parameters, the changes in the parameters happen as a side effect
"""
gradients = dict()
fx = f()
for p in self.parameters_to_optimise:
original = self.parameters[p].get_value()
grad = np.zeros_like(original)
if np.prod(original.shape) > 1:
for index, _ in np.ndenumerate(original):
xh = original.copy()
xh[index] += delta
self.parameters[p].set_value(xh)
grad[index] = (f() - fx) / delta
self.parameters[p].set_value(original)
else:
xh = original.copy()
xh += delta
self.parameters[p].set_value(xh)
grad = (f() - fx) / delta
self.parameters[p].set_value(original)
gradients[p] = grad
return gradients
def test_reduce_sum_axis_zero():
ctx = ndarray.gpu(0)
shape = (500, 200, 100)
to_shape = (200, 100)
x = np.random.uniform(0, 20, shape).astype(np.float32)
arr_x = ndarray.array(x, ctx=ctx)
arr_y = ndarray.empty(to_shape, ctx=ctx)
gpu_op.reduce_sum_axis_zero(arr_x, arr_y)
y = arr_y.asnumpy()
y_ = np.sum(x, axis=0)
for index, _ in np.ndenumerate(y):
v = y[index]
v_ = y_[index]
if abs((v - v_) / v_) > 1e-4:
print(index, v, v_)
np.testing.assert_allclose(np.sum(x, axis=0), y, rtol=1e-5)
def _dateToISO(indict):
"""
covert datetimes to iso strings inside of datamodel attributes
"""
retdict = dmcopy(indict)
if isinstance(indict, dict):
for key in indict:
if isinstance(indict[key], datetime.datetime):
retdict[key] = retdict[key].isoformat()
elif hasattr(indict[key], '__iter__'):
for idx, el in enumerate(indict[key]):
if isinstance(el, datetime.datetime):
retdict[key][idx] = el.isoformat()
else:
if isinstance(indict, datetime.datetime):
retdict = retdict.isoformat()
elif hasattr(indict, '__iter__'):
retdict = numpy.asanyarray(indict)
for idx, el in numpy.ndenumerate(indict):
if isinstance(el, datetime.datetime):
retdict[idx] = el.isoformat()
return retdict
def _flatten_data(data, chart_cfg, switch_zy=False):
plot_axes_def = [(0, XAxis), (1, YAxis)]
# Inject categories into the axis definitions of the plot
if isinstance(data, NDFrame):
for i, plot_axis in plot_axes_def[:data.ndim]:
categories = data.axes[i]
# Skip numeric indices
if not categories.is_numeric():
chart_cfg = chart_cfg.inherit_many(plot_axis(categories=list(categories)))
data = [list(index) + [value] for index, value in list(np.ndenumerate(data))]
if switch_zy:
for i in xrange(len(data)):
tmp = data[i][-1]
data[i][-1] = data[i][-2]
data[i][-2] = tmp
return data, chart_cfg
def returnAmplitudeFromListOfFunctionValues(self, listOfFunctionValues, additive=False):
"""Helper function for the amplitude setting function
[f(x), g(y), ...]
additive=True => F(x, y, ...) = f(x) + g(y) + ...
additive=False => F(x, y, ...) = f(x) * g(y) * ..."""
output = self.functionSpaceZero()
if additive:
initialValue = 0.0
else:
initialValue = 1.0
for indexTuple, value in np.ndenumerate(output):
newValue = initialValue
for tupleIndex, tupleValue in enumerate(indexTuple):
if additive:
newValue += listOfFunctionValues[tupleIndex][tupleValue]
else:
newValue *= listOfFunctionValues[tupleIndex][tupleValue]
output[indexTuple] = newValue
return output
def generate(width, height, s, output):
canvas = np.zeros((height, width), dtype='float64')
max_d = math.sqrt(width**2 + height**2) / 2
offset_angular = 0
if (width >= height):
offset_angular = math.pi / 4
for (i, j), _ in np.ndenumerate(canvas):
y = height // 2 - i
x = j - width // 2
d = math.sqrt(x**2 + y**2)
t = math.atan2(y, x)
canvas[i,j] = (255 / 4) * \
(2 + radial_sin(d, s, t) + angular_sin (
d, t, max_d, s, offset_angular))
f = open(output, 'wb')
w = png.Writer(width, height, greyscale=True)
w.write(f, canvas)
f.close()
def sample(self):
self._update_m()
indices = np.ndenumerate(self.count_k_by_j)
lgg.debug('Sample m...')
for ind in indices:
j, k = ind[0]
count = ind[1]
if count > 0:
# Sample number of tables in j serving dishe k
params = self.prob_jk(j, k)
sample = categorical(params) + 1
else:
sample = 0
self.m[j, k] = sample
self.m_dotk = self.m.sum(0)
self.purge_empty_tables()
return self.m
def cartopy_xlim(self, geobounds):
"""Return the x extents in projected coordinates for cartopy.
Returns:
:obj:`list`: A pair of [xmin, xmax].
See Also:
:mod:`cartopy`, :mod:`matplotlib`
"""
try:
_ = len(geobounds)
except TypeError:
x_extents= self._cart_extents(geobounds)[0]
else:
extents = self._cart_extents(geobounds)
x_extents = np.empty(extents.shape, np.object)
for idxs, extent in np.ndenumerate(extents):
x_extents[idxs] = extent[0]
return x_extents
def cartopy_ylim(self, geobounds):
"""Return the y extents in projected coordinates for cartopy.
Returns:
:obj:`list`: A pair of [ymin, ymax].
See Also:
:mod:`cartopy`, :mod:`matplotlib`
"""
try:
_ = len(geobounds)
except TypeError:
y_extents= self._cart_extents(geobounds)[1]
else:
extents = self._cart_extents(geobounds)
y_extents = np.empty(extents.shape, np.object)
for idxs, extent in np.ndenumerate(extents):
y_extents[idxs] = extent[1]
return y_extents
def detect_face_12net(cls_prob,roi,out_side,scale,width,height,threshold):
in_side = 2*out_side+11
stride = 0
if out_side != 1:
stride = float(in_side-12)/(out_side-1)
boundingBox = []
for (x,y), prob in np.ndenumerate(cls_prob):
if(prob >= threshold):
original_x1 = int((stride*x + 1)*scale)
original_y1 = int((stride*y + 1)*scale)
original_w = int((12.0 -1)*scale)
original_h = int((12.0 -1)*scale)
original_x2 = original_x1 + original_w
original_y2 = original_y1 + original_h
rect = []
x1 = int(round(max(0 , original_x1 + original_w * roi[0][x][y])))
y1 = int(round(max(0 , original_y1 + original_h * roi[1][x][y])))
x2 = int(round(min(width , original_x2 + original_w * roi[2][x][y])))
y2 = int(round(min(height, original_y2 + original_h * roi[3][x][y])))
if x2>x1 and y2>y1:
rect = [x1,y1,x2,y2,prob]
boundingBox.append(rect)
return NMS(boundingBox,0.5,'iou')
def hinton(matrix, max_weight=None, ax=None):
"""Draw Hinton diagram for visualizing a weight matrix."""
ax = ax if ax is not None else plt.gca()
if not max_weight:
max_weight = 2 ** np.ceil(np.log(np.abs(matrix).max()) / np.log(2))
ax.patch.set_facecolor('gray')
ax.set_aspect('equal', 'box')
ax.xaxis.set_major_locator(plt.NullLocator())
ax.yaxis.set_major_locator(plt.NullLocator())
for (x, y), w in np.ndenumerate(matrix):
color = 'white' if w > 0 else 'black'
size = np.sqrt(np.abs(w) / max_weight)
rect = plt.Rectangle([x - size / 2, y - size / 2], size, size,
facecolor=color, edgecolor=color)
ax.add_patch(rect)
ax.autoscale_view()
ax.invert_yaxis()
def sample_crp_tablecounts(concentration,customers,colweights):
m = np.zeros_like(customers)
tot = customers.sum()
randseq = np.random.random(tot)
starts = np.empty_like(customers)
starts[0,0] = 0
starts.flat[1:] = np.cumsum(np.ravel(customers)[:customers.size-1])
for (i,j), n in np.ndenumerate(customers):
w = colweights[j]
for k in xrange(n):
m[i,j] += randseq[starts[i,j]+k] \
< (concentration * w) / (k + concentration * w)
return m
### Entropy
def sample_crp_tablecounts(concentration,customers,colweights):
m = np.zeros_like(customers)
tot = customers.sum()
randseq = np.random.random(tot)
starts = np.empty_like(customers)
starts[0,0] = 0
starts.flat[1:] = np.cumsum(np.ravel(customers)[:customers.size-1])
for (i,j), n in np.ndenumerate(customers):
w = colweights[j]
for k in xrange(n):
m[i,j] += randseq[starts[i,j]+k] \
< (concentration * w) / (k + concentration * w)
return m
### Entropy
def hmm_trans_matrix(self):
# NOTE: more general version, allows different delays, o/w we could
# construct with np.kron
if self._hmm_trans_matrix is None:
ps, delays = map(np.array,zip(*[(d.p,d.delay) for d in self.dur_distns]))
starts, ends = cumsum(delays,strict=True), cumsum(delays,strict=False)
trans_matrix = self._hmm_trans_matrix = np.zeros((ends[-1],ends[-1]))
for (i,j), Aij in np.ndenumerate(self.trans_matrix):
block = trans_matrix[starts[i]:ends[i],starts[j]:ends[j]]
if i == j:
block[:-1,1:] = np.eye(block.shape[0]-1)
block[-1,-1] = 1-ps[i]
else:
block[-1,0] = ps[j]*Aij
return self._hmm_trans_matrix
def mf_bwd_trans_matrix(self):
rs = self.rs
starts, ends = cumsum(rs,strict=True), cumsum(rs,strict=False)
trans_matrix = np.zeros((ends[-1],ends[-1]))
Elnps, Eln1mps = zip(*[d._fixedr_distns[d.ridx]._mf_expected_statistics() for d in self.dur_distns])
Eps, E1mps = np.exp(Elnps), np.exp(Eln1mps) # NOTE: actually exp(E[ln(p)]) etc
enters = self.mf_bwd_enter_rows(rs,Eps,E1mps)
for (i,j), Aij in np.ndenumerate(self.mf_trans_matrix):
block = trans_matrix[starts[i]:ends[i],starts[j]:ends[j]]
block[-1,:] = Aij * eE1mps[i] * enters[j]
if i == j:
block[...] += np.diag(np.repeat(eEps[i],rs[i])) \
+ np.diag(np.repeat(eE1mps[i],rs[i]-1),k=1)
assert np.all(trans_matrix >= 0)
return trans_matrix
def hmm_trans_matrix_orig(self):
rs, ps, delays = self.rs, self.ps, self.delays
starts, ends = cumsum(rs+delays,strict=True), cumsum(rs+delays,strict=False)
trans_matrix = np.zeros((ends[-1],ends[-1]))
enters = self.bwd_enter_rows
for (i,j), Aij in np.ndenumerate(self.trans_matrix):
block = trans_matrix[starts[i]:ends[i],starts[j]:ends[j]]
if delays[i] == 0:
block[-1,:rs[j]] = Aij * enters[j] * (1-ps[i])
else:
block[-1,:rs[j]] = Aij * enters[j]
if i == j:
block[:rs[i],:rs[i]] += \
np.diag(np.repeat(ps[i],rs[i])) + np.diag(np.repeat(1-ps[i],rs[i]-1),k=1)
if delays[i] > 0:
block[rs[i]-1,rs[i]] = (1-ps[i])
block[rs[i]:,rs[i]:] = np.eye(delays[i],k=1)
assert np.allclose(trans_matrix.sum(1),1.)
return trans_matrix
def hmm_trans_matrix_1(self):
rs, ps, delays = self.rs, self.ps, self.delays
starts, ends = cumsum(rs+delays,strict=True), cumsum(rs+delays,strict=False)
trans_matrix = np.zeros((ends[-1],ends[-1]))
enters = self.bwd_enter_rows
for (i,j), Aij in np.ndenumerate(self.trans_matrix):
block = trans_matrix[starts[i]:ends[i],starts[j]:ends[j]]
block[-1,:rs[j]] = Aij * enters[j] * (1-ps[i])
if i == j:
block[-rs[i]:,-rs[i]:] += \
np.diag(np.repeat(ps[i],rs[i])) + np.diag(np.repeat(1-ps[i],rs[i]-1),k=1)
if delays[i] > 0:
block[:delays[i]:,:delays[i]] = np.eye(delays[i],k=1)
block[delays[i]-1,delays[i]] = 1
assert np.allclose(trans_matrix.sum(1),1.)
return trans_matrix
def hmm_trans_matrix_2(self):
rs, ps, delays = self.rs, self.ps, self.delays
starts, ends = cumsum(rs+delays,strict=True), cumsum(rs+delays,strict=False)
trans_matrix = np.zeros((ends[-1],ends[-1]))
enters = self.bwd_enter_rows
for (i,j), Aij in np.ndenumerate(self.trans_matrix):
block = trans_matrix[starts[i]:ends[i],starts[j]:ends[j]]
block[-1,0] = Aij * (1-ps[i])
if i == j:
block[-rs[i]:,-rs[i]:] += \
np.diag(np.repeat(ps[i],rs[i])) + np.diag(np.repeat(1-ps[i],rs[i]-1),k=1)
if delays[i] > 0:
block[:delays[i]:,:delays[i]] = np.eye(delays[i],k=1)
block[delays[i]-1,-rs[i]:] = enters[i]
assert np.allclose(trans_matrix.sum(1),1.)
return trans_matrix
def convert_numpy_array_to_line_chart(array, ntype):
array = np.sort(array)[::-1]
rows = []
previous_count = None
for (index,), count in np.ndenumerate(array):
if index == 0 or index == len(array)-1:
rows.append([index, ntype(count)])
elif previous_count != count:
previous_index = rows[-1][0]
if previous_index != index - 1:
rows.append([index - 1, ntype(previous_count)])
rows.append([index, ntype(count)])
previous_count = count
return rows
def cal_hist(t1_rep, t2_rep, qnum, hist_size):
#qnum = len(t1_rep)
mhist = np.zeros((qnum, hist_size), dtype=np.float32)
mm = t1_rep.dot(np.transpose(t2_rep))
for (i,j), v in np.ndenumerate(mm):
if i >= qnum:
break
vid = int((v + 1.) / 2. * (hist_size - 1.))
mhist[i][vid] += 1.
mhist += 1.
mhist = np.log10(mhist)
return mhist.flatten()
def cal_binsum(t1_rep, t2_rep, qnum, bin_num):
mbinsum = np.zeros((qnum, bin_num), dtype=np.float32)
mm = t1_rep.dot(np.transpose(t2_rep))
for (i, j), v in np.ndenumerate(mm):
if i >= qnum:
break
vid = int((v + 1.) / 2. * (bin_num - 1.))
mbinsum[i][vid] += v
#mhist += 1. # smooth is not needed for computing bin sum
#mhist = np.log10(mhist) # not needed for computing bin sum
return mbinsum.flatten()
def cal_binsum(t1_rep, t2_rep, qnum, bin_num):
mbinsum = np.zeros((qnum, bin_num), dtype=np.float32)
mm = t1_rep.dot(np.transpose(t2_rep))
for (i, j), v in np.ndenumerate(mm):
if i >= qnum:
break
vid = int((v + 1.) / 2. * (bin_num - 1.))
mbinsum[i][vid] += v
#mhist += 1. # smooth is not needed for computing bin sum
#mhist = np.log10(mhist) # not needed for computing bin sum
return mbinsum.flatten()
def assign_node_constraints(snic, axes, face_constraints):
"""assign node constraints to prescribed node planes
Nodes shared on multiple faces have are assigned with the following order
of precedence: z, y, x
:param snic: sorted node IDs and coordinates from nodes.dyn
:param axes: mesh axes [x, y, z]
:param face_constraints: list of DOF strings ordered by
((xmin, max), (ymin, ...)
(e.g., (('1,1,1,1,1,1' , '0,1,0,0,1,0'),...)
:return: bcdict - dictionary of node BC to be written to bc.dyn
"""
from fem_mesh import extractPlane
from numpy import ndenumerate
bcdict = {}
for axis in range(0, 3):
for axlim in range(0, 2):
if axlim == 0:
axis_limit = axes[axis].min()
else:
axis_limit = axes[axis].max()
planeNodeIDs = extractPlane(snic, axes, (axis, axis_limit))
for i, id in ndenumerate(planeNodeIDs):
bcdict[id] = face_constraints[axis][axlim]
return bcdict
def constrain_sym_pml_nodes(bcdict, snic, axes, pml_elems, edge_constraints):
"""make sure that all "side" nodes for the PML elements are fully
constrained, instead of being assigned the symmetry constraints
THIS FUNCTION IS NOT NEEDED!!
:param bcdict:
:param snic:
:param axes:
:param pml_elems:
:param edge_constraints:
:return: bcdict
"""
from fem_mesh import extractPlane
from numpy import ndenumerate
# look for x symmetry face
for axis in range(0, 2):
if edge_constraints[0][axis][0]:
axis_limit = axes[axis].min()
elif edge_constraints[0][axis][1]:
axis_limit = axes[axis].max()
if axis_limit is not None:
planeNodeIDs = extractPlane(snic, axes, (axis, axis_limit))
pml_node_ids_zmin = planeNodeIDs[:, 0:(pml_elems[2][0] + 1)]
pml_node_ids_zmax = planeNodeIDs[:, -(pml_elems[2][1] + 1):]
for i, id in ndenumerate(pml_node_ids_zmin):
bcdict[id] = "%s" % '1,1,1,1,1,1'
for i, id in ndenumerate(pml_node_ids_zmax):
bcdict[id] = "%s" % '1,1,1,1,1,1'
axis_limit = None
return bcdict
def create_zdisp(nodeidlist, disp_slice_z_only, zdisp):
"""create zdisp array from squeezed disp_slice at appropriate index
:param nodeidlist: first column of disp_slice with node IDs in row order
:param disp_slice_z_only: squeezed disp_slice of just zisp
:returns: zdisp -- array of z-disp in rows corresponding to node ID
(for fast read access)
"""
import numpy as np
for i, nodeid in np.ndenumerate(nodeidlist):
zdisp[nodeid] = disp_slice_z_only[i]
return zdisp
def test_ndenumerate_crash(self):
# Ticket 1140
# Shouldn't crash:
list(np.ndenumerate(np.array([[]])))
def expand(self, move_probabilities):
self.children = {move: MCTSNode(self, move, prob)
for move, prob in np.ndenumerate(move_probabilities)}
# Pass should always be an option! Say, for example, seki.
self.children[None] = MCTSNode(self, None, 0)
def load_label(self, idx):
"""
Load label image as 1 x height x width integer array of label indices.
Shift labels so that classes are 0-39 and void is 255 (to ignore it).
The leading singleton dimension is required by the loss.
"""
label = scipy.io.loadmat('{}/segmentation/img_{}.mat'.format(self.nyud_dir, idx))['groundTruth'][0,0][0,0]['SegmentationClass'].astype(np.uint16)
for (x,y), value in np.ndenumerate(label):
label[x,y] = self.class_map[0][value-1]
label = label.astype(np.uint8)
label -= 1 # rotate labels
label = label[np.newaxis, ...]
# pdb.set_trace()
return label
def load_label(self, idx):
"""
Load label image as 1 x height x width integer array of label indices.
Shift labels so that classes are 0-39 and void is 255 (to ignore it).
The leading singleton dimension is required by the loss.
"""
label = scipy.io.loadmat('{}/segmentation/img_{}.mat'.format(self.nyud_dir, idx))['groundTruth'][0,0][0,0]['SegmentationClass'].astype(np.uint16)
for (x,y), value in np.ndenumerate(label):
label[x,y] = self.class_map[0][value-1]
label = label.astype(np.uint8)
label -= 1 # rotate labels
label = label[np.newaxis, ...]
# pdb.set_trace()
return label
def load_label(self, idx):
"""
Load label image as 1 x height x width integer array of label indices.
Shift labels so that classes are 0-39 and void is 255 (to ignore it).
The leading singleton dimension is required by the loss.
"""
label = scipy.io.loadmat('{}/segmentation/img_{}.mat'.format(self.nyud_dir, idx))['groundTruth'][0,0][0,0]['SegmentationClass'].astype(np.uint16)
for (x,y), value in np.ndenumerate(label):
label[x,y] = self.class_map[0][value-1]
label = label.astype(np.uint8)
label -= 1 # rotate labels
label = label[np.newaxis, ...]
# pdb.set_trace()
return label
def build_from_index(self, index, paths, dirs):
""" Build index from another index for indices given. """
if isinstance(paths, dict):
self._paths = dict((file, paths[file]) for file in index)
else:
self._paths = dict((file, paths[pos]) for pos, file in np.ndenumerate(index))
self.dirs = dirs
return index
def test_ndenumerate_crash(self):
# Ticket 1140
# Shouldn't crash:
list(np.ndenumerate(np.array([[]])))
def analyze_false(validData,validDataNumbers,validLabels,model):
'Calculating precision and recall for best model...'
predictions = np.squeeze((model.predict(validDataNumbers) > 0.5).astype('int32'))
c1_inds = np.where(validLabels == 1)[0]
pos_inds = np.where((predictions+validLabels) == 2)[0] #np.squeeze(predictions) == validLabels
neg_inds = np.setdiff1d(c1_inds,pos_inds)
seq_lengths = np.zeros((validData.shape[0]))
for ind,row in np.ndenumerate(validData):
seq_lengths[ind] = len(wordpunct_tokenize(row.lower().strip()))
mean_true_length = np.mean(seq_lengths[pos_inds])
mean_false_length = np.mean(seq_lengths[neg_inds])
return mean_false_length,mean_true_length
def rgb_pixeldata(self):
pixels = [np.ndarray(shape=[64, 128], dtype=np.dtype('u1'), order='C'),
np.ndarray(shape=[64, 128], dtype=np.dtype('u1'), order='C'),
np.ndarray(shape=[64, 128], dtype=np.dtype('u1'), order='C')]
for s in range(0, len(pixels)):
for (y, x), value in np.ndenumerate(pixels[s]):
if s == 0:
value = (x * 255) / 128
if s == 1:
value = (y * 255) / 64
if s == 2:
value = 255 - ((y * 255) / 64)
pixels[s].itemset((y, x), value)
return pixels
def grey_pixeldata(self):
pixels = np.ndarray(shape=[64, 128], dtype=np.dtype('f4'), order='C')
for (y, x), value in np.ndenumerate(pixels):
value = x/128.0 + y/64.0
pixels.itemset((y, x), value)
return pixels
def argmin_n(m, n):
best_values = []
best_index = []
max_value_heap = []
for index, value in np.ndenumerate(m):
if len(best_values) == n:
if -1 * value < max_value_heap[0][0]:
# value is larger than the largest value
# and the list is at capacity
continue
_, pos = heapq.heappop(max_value_heap)
best_values[pos] = value
best_index[pos] = index
heapq.heappush(max_value_heap, (-1 * value, pos))
else:
heapq.heappush(max_value_heap, (-1 * value, len(best_values)))
best_values.append(value)
best_index.append(index)
pos, best_values = zip(*sorted(enumerate(best_values), key=lambda e: e[1]))
best_index = [best_index[i] for i in pos]
return best_index
def argmax_n(m, n):
best_values = []
best_index = []
max_value_heap = []
for index, value in np.ndenumerate(m):
if len(best_values) == n:
if value < max_value_heap[0][0]:
# value is smaller than the largest value
# and the list is at capacity
continue
_, pos = heapq.heappop(max_value_heap)
best_values[pos] = value
best_index[pos] = index
heapq.heappush(max_value_heap, (value, pos))
else:
heapq.heappush(max_value_heap, (value, len(best_values)))
best_values.append(value)
best_index.append(index)
pos, best_values = zip(
*sorted(enumerate(best_values), key=lambda e: e[1], reverse=True))
best_index = [best_index[i] for i in pos]
return best_index
def __init__(self, tensors, up_label="up", right_label="right",
down_label="down", left_label="left",
copy_data=True):
self.up_label = up_label
self.right_label = right_label
self.down_label = down_label
self.left_label = left_label
if copy_data:
# Creates copies of tensors in memory
copied_tensors = []
for row in tensors:
copied_tensors.append([x.copy() for x in row])
self.data = np.array(copied_tensors)
else:
# This will not create copies of tensors in memory
# (just link to originals)
self.data = np.array(tensors)
# Every tensor will have four indices corresponding to
# "left", "right" and "up", "down" labels.
for i, x in np.ndenumerate(self.data):
if left_label not in x.labels: x.add_dummy_index(left_label)
if right_label not in x.labels: x.add_dummy_index(right_label)
if up_label not in x.labels: x.add_dummy_index(up_label)
if down_label not in x.labels: x.add_dummy_index(down_label)
# Add container emulation
def getCellParameters(self, array, fn=np.mean):
out = np.arange(len(self.cells),
dtype=float).reshape(self.opts['grid'])
s = array.shape
for (i, j), n in np.ndenumerate(out):
m = self.cells[int(n)].getMask(s)
out[i, j] = fn(array[m])
return out
def Find_HighlightedEdges(self,weight = 0):
self.ThresholdData = np.copy(self.data)
# low_values_indices = self.ThresholdData < weight # Where values are low
# self.ThresholdData[low_values_indices] = 0
# graterindices = [ (i,j) for i,j in np.ndenumerate(self.ThresholdData) if any(i > j) ]
# self.ThresholdData[graterindices[:1]] = 0
# self.ThresholdData = np.tril(self.ThresholdData)
# print self.ThresholdData, "is the data same??"
"""
test 2 highlighted edges there
"""
# np.savetxt('test2.txt', self.ThresholdData, delimiter=',', fmt='%1.4e')
self.g = nx.from_numpy_matrix(self.ThresholdData)
def finite_differences(func, inputs, func_output_shape=(), epsilon=1e-5):
"""
Computes gradients via finite differences.
derivative = (func(x+epsilon) - func(x-epsilon)) / (2*epsilon)
Args:
func: Function to compute gradient of. Inputs and outputs can be
arbitrary dimension.
inputs: Vector value to compute gradient at.
func_output_shape: Shape of the output of func. Default is
empty-tuple, which works for scalar-valued functions.
epsilon: Difference to use for computing gradient.
Returns:
Gradient vector of each dimension of func with respect to each
dimension of input.
"""
gradient = np.zeros(inputs.shape+func_output_shape)
for idx, _ in np.ndenumerate(inputs):
test_input = np.copy(inputs)
test_input[idx] += epsilon
obj_d1 = func(test_input)
assert obj_d1.shape == func_output_shape
test_input = np.copy(inputs)
test_input[idx] -= epsilon
obj_d2 = func(test_input)
assert obj_d2.shape == func_output_shape
diff = (obj_d1 - obj_d2) / (2 * epsilon)
gradient[idx] += diff
return gradient
def __init__(self, row, column):
self.rewards = np.full((row, column), -0.2)
self.states = np.ones((row, column), dtype=np.int)
self.states[1, 1] = -1
self.index_list = [index for index, x in np.ndenumerate(self.states) if x > 0]
self._init_next_state_table()
self.rewards[0, column - 1] = 1
self.rewards[0, 0] = 1
self.rewards[1, column - 1] = -1
self.terminal = [(0, column - 1), (0, 0)]