# Python numpy.argsort() Examples

The following are 30 code examples of numpy.argsort(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module , or try the search function .
Example #1
```def plot_rhodelta_rho(rho, delta):
'''
Plot scatter diagram for rho*delta_rho points

Args:
rho   : rho list
delta : delta list
'''
logger.info("PLOT: rho*delta_rho plot")
y=rho*delta
r_index=np.argsort(-y)
x=np.zeros(y.shape[0])
idx=0
for r in r_index:
x[r]=idx
idx+=1
plt.figure(2)
plt.clf()
plt.scatter(x,y)
plt.xlabel('sorted rho')
plt.ylabel('rho*delta')
plt.title("Decision Graph RhoDelta-Rho")
plt.show()
plt.savefig('Decision Graph RhoDelta-Rho.jpg') ```
Example #2
 Source File: run.py    From fullrmc with GNU Affero General Public License v3.0 6 votes
```def about0(ENGINE, rang=5, recur=100, refine=True, explore=False):
ENGINE.set_groups_as_molecules()
[g.set_move_generator(RotationAboutSymmetryAxisGenerator(axis=0, amplitude=180)) for g in ENGINE.groups]
# set selector
centers   = [np.sum(ENGINE.realCoordinates[g.indexes], axis=0)/len(g) for g in ENGINE.groups]
distances = [np.sqrt(np.add.reduce(c**2)) for c in centers]
order     = np.argsort(distances)
gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order = order ), recur=recur, refine=refine, explore=explore)
ENGINE.set_group_selector(gs)
# number of steps
nsteps = recur*len(ENGINE.groups)
for stepIdx in range(rang):
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)

# ############ RUN ROTATION ABOUT SYMM AXIS 1 ############ # ```
Example #3
 Source File: run.py    From fullrmc with GNU Affero General Public License v3.0 6 votes
```def about1(ENGINE, rang=5, recur=10, refine=True, explore=False):
ENGINE.set_groups_as_molecules()
[g.set_move_generator(RotationAboutSymmetryAxisGenerator(axis=1, amplitude=180)) for g in ENGINE.groups]
# set selector
centers   = [np.sum(ENGINE.realCoordinates[g.indexes], axis=0)/len(g) for g in ENGINE.groups]
distances = [np.sqrt(np.add.reduce(c**2)) for c in centers]
order     = np.argsort(distances)
gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order = order ), recur=recur, refine=refine, explore=explore)
ENGINE.set_group_selector(gs)
# number of steps
nsteps = recur*len(ENGINE.groups)
for stepIdx in range(rang):
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)

# ############ RUN ROTATION ABOUT SYMM AXIS 2 ############ # ```
Example #4
 Source File: run.py    From fullrmc with GNU Affero General Public License v3.0 6 votes
```def about2(ENGINE, rang=5, recur=100, refine=True, explore=False):
ENGINE.set_groups_as_molecules()
[g.set_move_generator(RotationAboutSymmetryAxisGenerator(axis=2, amplitude=180)) for g in ENGINE.groups]
# set selector
centers   = [np.sum(ENGINE.realCoordinates[g.indexes], axis=0)/len(g) for g in ENGINE.groups]
distances = [np.sqrt(np.add.reduce(c**2)) for c in centers]
order     = np.argsort(distances)
gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order = order ), recur=recur, refine=refine, explore=explore)
ENGINE.set_group_selector(gs)
# number of steps
nsteps = recur*len(ENGINE.groups)
for stepIdx in range(rang):
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)

# ############ RUN TRANSLATION ALONG SYMM AXIS 0 ############ # ```
Example #5
```def k_nearest_neighbor(self, sequence):
# Calculate dist_matrix
dist_array = pdist(sequence)
dist_matrix = squareform(dist_array)
# Construct tour
new_sequence = [sequence[0]]
current_city = 0
visited_cities = [0]
for i in range(1,len(sequence)):
j = np.random.randint(0,min(len(sequence)-i,self.kNN))
next_city = [index for index in dist_matrix[current_city].argsort() if index not in visited_cities][j]
visited_cities.append(next_city)
new_sequence.append(sequence[next_city])
current_city = next_city
return np.asarray(new_sequence)

# Generate random TSP-TW instance ```
Example #6
 Source File: layers.py    From DeepLung with GNU General Public License v3.0 6 votes
```def nms(output, nms_th):
if len(output) == 0:
return output

output = output[np.argsort(-output[:, 0])]
bboxes = [output[0]]

for i in np.arange(1, len(output)):
bbox = output[i]
flag = 1
for j in range(len(bboxes)):
if iou(bbox[1:5], bboxes[j][1:5]) >= nms_th:
flag = -1
break
if flag == 1:
bboxes.append(bbox)

bboxes = np.asarray(bboxes, np.float32)
return bboxes ```
Example #7
 Source File: labels.py    From neuropythy with GNU Affero General Public License v3.0 6 votes
```def cmap(self, data=None):
'''
lblidx.cmap() yields a colormap for the given label index object that assumes that the data
being plotted will be rescaled such that label 0 is 0 and the highest label value in the
label index is equal to 1.
lblidx.cmap(data) yields a colormap that will correctly color the labels given in data if
data is scaled such that its minimum and maximum value are 0 and 1.
'''
import matplotlib.colors
from_list = matplotlib.colors.LinearSegmentedColormap.from_list
if data is None: return self.colormap
data = np.asarray(data).flatten()
(vmin,vmax) = (np.min(data), np.max(data))
ii  = np.argsort(self.ids)
ids = np.asarray(self.ids)[ii]
if vmin == vmax:
(vmin,vmax,ii) = (vmin-0.5, vmax+0.5, vmin)
clr = self.color_lookup(ii)
return from_list('label1', [(0, clr), (1, clr)])
q   = (ids >= vmin) & (ids <= vmax)
ids = ids[q]
clrs = self.color_lookup(ids)
vals = (ids - vmin) / (vmax - vmin)
return from_list('label%d' % len(vals), list(zip(vals, clrs))) ```
Example #8
 Source File: run.py    From fullrmc with GNU Affero General Public License v3.0 6 votes
```def along0(ENGINE, rang=5, recur=100, refine=False, explore=True):
ENGINE.set_groups_as_molecules()
[g.set_move_generator(TranslationAlongSymmetryAxisGenerator(axis=0, amplitude=0.1)) for g in ENGINE.groups]
# set selector
centers   = [np.sum(ENGINE.realCoordinates[g.indexes], axis=0)/len(g) for g in ENGINE.groups]
distances = [np.sqrt(np.add.reduce(c**2)) for c in centers]
order     = np.argsort(distances)
gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order = order ), recur=recur, refine=refine, explore=explore)
ENGINE.set_group_selector(gs)
# number of steps
nsteps = recur*len(ENGINE.groups)
for stepIdx in range(rang):
LOGGER.info("Running 'along0' mode step %i"%(stepIdx))
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)

# ############ RUN TRANSLATION ALONG SYMM AXIS 1 ############ # ```
Example #9
 Source File: run.py    From fullrmc with GNU Affero General Public License v3.0 6 votes
```def along2(ENGINE, rang=5, recur=100, refine=False, explore=True):
ENGINE.set_groups_as_molecules()
[g.set_move_generator(TranslationAlongSymmetryAxisGenerator(axis=2, amplitude=0.1)) for g in ENGINE.groups]
# set selector
centers   = [np.sum(ENGINE.realCoordinates[g.indexes], axis=0)/len(g) for g in ENGINE.groups]
distances = [np.sqrt(np.add.reduce(c**2)) for c in centers]
order     = np.argsort(distances)
gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order = order ), recur=recur, refine=refine, explore=explore)
ENGINE.set_group_selector(gs)
# number of steps
nsteps = recur*len(ENGINE.groups)
for stepIdx in range(rang):
LOGGER.info("Running 'along2' mode step %i"%(stepIdx))
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)

# ############ RUN MOLECULES ############ # ```
Example #10
 Source File: utils.py    From pruning_yolov3 with GNU General Public License v3.0 6 votes
```def print_mutation(hyp, results, bucket=''):
# Print mutation results to evolve.txt (for use with train.py --evolve)
a = '%10s' * len(hyp) % tuple(hyp.keys())  # hyperparam keys
b = '%10.3g' * len(hyp) % tuple(hyp.values())  # hyperparam values
c = '%10.3g' * len(results) % results  # results (P, R, mAP, F1, test_loss)
print('\n%s\n%s\nEvolved fitness: %s\n' % (a, b, c))

if bucket:

with open('evolve.txt', 'a') as f:  # append result
f.write(c + b + '\n')
np.savetxt('evolve.txt', x[np.argsort(-fitness(x))], '%10.3g')  # save sort by fitness

if bucket:
os.system('gsutil cp evolve.txt gs://%s' % bucket)  # upload evolve.txt ```
Example #11
 Source File: frocwrtdetpepchluna16.py    From DeepLung with GNU General Public License v3.0 6 votes
```def nms(output, nms_th):
if len(output) == 0:
return output
output = output[np.argsort(-output[:, 0])]
bboxes = [output[0]]
for i in np.arange(1, len(output)):
bbox = output[i]
flag = 1
for j in range(len(bboxes)):
if iou(bbox[1:5], bboxes[j][1:5]) >= nms_th:
flag = -1
break
if flag == 1:
bboxes.append(bbox)
bboxes = np.asarray(bboxes, np.float32)
return bboxes ```
Example #12
 Source File: testdet2cls.py    From DeepLung with GNU General Public License v3.0 6 votes
```def nms(output, nms_th):
if len(output) == 0: return output
output = output[np.argsort(-output[:, 0])]
bboxes = [output[0]]
for i in np.arange(1, len(output)):
bbox = output[i]
flag = 1
for j in range(len(bboxes)):
if iou(bbox[1:5], bboxes[j][1:5]) >= nms_th:
flag = -1
break
if flag == 1: bboxes.append(bbox)
bboxes = np.asarray(bboxes, np.float32)
return bboxes
# find the mapping
Example #13
 Source File: det2cls.py    From DeepLung with GNU General Public License v3.0 6 votes
```def nms(output, nms_th):
if len(output) == 0: return output
output = output[np.argsort(-output[:, 0])]
bboxes = [output[0]]
for i in np.arange(1, len(output)):
bbox = output[i]
flag = 1
for j in range(len(bboxes)):
if iou(bbox[1:5], bboxes[j][1:5]) >= nms_th:
flag = -1
break
if flag == 1: bboxes.append(bbox)
bboxes = np.asarray(bboxes, np.float32)
return bboxes
# find the mapping
Example #14
 Source File: run.py    From fullrmc with GNU Affero General Public License v3.0 6 votes
```def shrink(ENGINE, newDim):
ENGINE.set_groups_as_molecules()
[g.set_move_generator( MoveGeneratorCollector(collection=[TranslationGenerator(amplitude=0.2),RotationGenerator(amplitude=5)],randomize=True) ) for g in ENGINE.groups]
# get groups order
centers   = [np.sum(ENGINE.realCoordinates[g.indexes], axis=0)/len(g) for g in ENGINE.groups]
distances = [np.sqrt(np.add.reduce(c**2)) for c in centers]
order     = np.argsort(distances)
# change boundary conditions
bcFrom = str([list(bc) for bc in ENGINE.boundaryConditions.get_vectors()] )
ENGINE.set_boundary_conditions(newDim)
bcTo   = str([list(bc) for bc in ENGINE.boundaryConditions.get_vectors()] )
LOGGER.info("boundary conditions changed from %s to %s"%(bcFrom,bcTo))
# set selector
recur = 200
gs = RecursiveGroupSelector(DefinedOrderSelector(ENGINE, order = order ), recur=recur, refine=True)
ENGINE.set_group_selector(gs)
# number of steps
nsteps = recur*len(ENGINE.groups)
for stepIdx in range(10):
LOGGER.info("Running 'shrink' mode step %i"%(stepIdx))
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
fname = "shrink_"+str(newDim).replace(".","p")

##########################################################################################
#####################################  RUN SIMULATION  ################################### ```
Example #15
```def forward_ocr(self, img_):
img_ = cv2.resize(img_, (80, 30))
img_ = img_.transpose(1, 0)
print(img_.shape)
img_ = img_.reshape((1, 80, 30))
print(img_.shape)
# img_ = img_.reshape((80 * 30))
img_ = np.multiply(img_, 1 / 255.0)
self.predictor.forward(data=img_, **self.init_state_dict)
prob = self.predictor.get_output(0)
label_list = []
for p in prob:
print(np.argsort(p))
max_index = np.argsort(p)[::-1][0]
label_list.append(max_index)
return self.__get_string(label_list) ```
Example #16
```def _peaks1D(self):
if self.num_src == 1:
self.src_idx[0] = np.argmax(self.P)
self.sources[:, 0] = self.loc[:, self.src_idx[0]]
self.phi_recon = self.theta[self.src_idx[0]]
else:
peak_idx = []
n = self.P.shape[0]
for i in range(self.num_loc):
# straightforward peak finding
if self.P[i] >= self.P[(i-1)%n] and self.P[i] > self.P[(i+1)%n]:
if len(peak_idx) == 0 or peak_idx[-1] != i-1:
if not (i == self.num_loc and self.P[i] == self.P[0]):
peak_idx.append(i)

peaks = self.P[peak_idx]
max_idx = np.argsort(peaks)[-self.num_src:]
self.src_idx = [peak_idx[k] for k in max_idx]
self.sources = self.loc[:, self.src_idx]
self.phi_recon = self.theta[self.src_idx]
self.num_src = len(self.src_idx)

# ------------------Miscellaneous Functions---------------------# ```
Example #17
```def classical_mds(self, D):
'''
Classical multidimensional scaling

Parameters
----------
D : square 2D ndarray
Euclidean Distance Matrix (matrix containing squared distances between points
'''

# Apply MDS algorithm for denoising
n = D.shape[0]
J = np.eye(n) - np.ones((n,n))/float(n)
G = -0.5*np.dot(J, np.dot(D, J))

s, U = np.linalg.eig(G)

# we need to sort the eigenvalues in decreasing order
s = np.real(s)
o = np.argsort(s)
s = s[o[::-1]]
U = U[:,o[::-1]]

S = np.diag(s)[0:self.dim,:]
self.X = np.dot(np.sqrt(S),U.T) ```
Example #18
```def _get_room_dimensions(file_name, resolution, origin, flip=False):
if fu.exists(file_name):
names = a.keys()
dims = np.concatenate(a.values(), axis=0).reshape((-1,6))
ind = np.argsort(names)
dims = dims[ind,:]
names = [names[x] for x in ind]
if flip:
dims_new = dims*1
dims_new[:,1] = -dims[:,4]
dims_new[:,4] = -dims[:,1]
dims = dims_new*1

dims = dims*100.
dims[:,0] = dims[:,0] - origin[0]
dims[:,1] = dims[:,1] - origin[1]
dims[:,3] = dims[:,3] - origin[0]
dims[:,4] = dims[:,4] - origin[1]
dims = dims / resolution
out = {'names': names, 'dims': dims}
else:
out = None
return out ```
Example #19
```def detect(self, text_proposals, scores, size):
# 删除得分较低的proposal
keep_inds = np.where(scores > TextLineCfg.TEXT_PROPOSALS_MIN_SCORE)[0]
text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

# 按得分排序
sorted_indices = np.argsort(scores.ravel())[::-1]
text_proposals, scores = text_proposals[sorted_indices], scores[sorted_indices]

# 对proposal做nms
keep_inds = nms(np.hstack((text_proposals, scores)), TextLineCfg.TEXT_PROPOSALS_NMS_THRESH)
text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

# 获取检测结果
text_recs = self.text_proposal_connector.get_text_lines(text_proposals, scores, size)
keep_inds = self.filter_boxes(text_recs)
return text_recs[keep_inds] ```
Example #20
```def test_lwlr(self):
# python -m unittest tests_regression.Tests_Regression.test_lwlr
import locally_weighted_linear_regression as lwlr1
from discomll.regression import locally_weighted_linear_regression as lwlr2

x_train, y_train, x_test, y_test = datasets.regression_data()
train_data, test_data = datasets.regression_data_discomll()

lwlr1 = lwlr1.Locally_Weighted_Linear_Regression()
taus = [1, 10, 25]
sorted_indices = np.argsort([str(el) for el in x_test[:, 1].tolist()])

for tau in taus:
thetas1, estimation1 = lwlr1.fit(x_train, y_train, x_test, tau=tau)
thetas1, estimation1 = np.array(thetas1)[sorted_indices], np.array(estimation1)[sorted_indices]

results = lwlr2.fit_predict(train_data, test_data, tau=tau)
thetas2, estimation2 = [], []

for x_id, (est, thetas) in result_iterator(results):
estimation2.append(est)
thetas2.append(thetas)

self.assertTrue(np.allclose(thetas1, thetas2, atol=1e-8))
self.assertTrue(np.allclose(estimation1, estimation2, atol=1e-3)) ```
Example #21
```def calc_pr(gt, out, wt=None):
if wt is None:
wt = np.ones((gt.size,1))

gt = gt.astype(np.float64).reshape((-1,1))
wt = wt.astype(np.float64).reshape((-1,1))
out = out.astype(np.float64).reshape((-1,1))

gt = gt*wt
tog = np.concatenate([gt, wt, out], axis=1)*1.
ind = np.argsort(tog[:,2], axis=0)[::-1]
tog = tog[ind,:]
cumsumsortgt = np.cumsum(tog[:,0])
cumsumsortwt = np.cumsum(tog[:,1])
prec = cumsumsortgt / cumsumsortwt
rec = cumsumsortgt / np.sum(tog[:,0])

ap = voc_ap(rec, prec)
return ap, rec, prec ```
Example #22
```def fit(self, Xs, Xt):
'''
Transform Xs and Xt
:param Xs: ns * n_feature, source feature
:param Xt: nt * n_feature, target feature
:return: Xs_new and Xt_new after TCA
'''
X = np.hstack((Xs.T, Xt.T))
X /= np.linalg.norm(X, axis=0)
m, n = X.shape
ns, nt = len(Xs), len(Xt)
e = np.vstack((1 / ns * np.ones((ns, 1)), -1 / nt * np.ones((nt, 1))))
M = e * e.T
M = M / np.linalg.norm(M, 'fro')
H = np.eye(n) - 1 / n * np.ones((n, n))
K = kernel(self.kernel_type, X, None, gamma=self.gamma)
n_eye = m if self.kernel_type == 'primal' else n
a, b = np.linalg.multi_dot([K, M, K.T]) + self.lamb * np.eye(n_eye), np.linalg.multi_dot([K, H, K.T])
w, V = scipy.linalg.eig(a, b)
ind = np.argsort(w)
A = V[:, ind[:self.dim]]
Z = np.dot(A.T, K)
Z /= np.linalg.norm(Z, axis=0)
Xs_new, Xt_new = Z[:, :ns].T, Z[:, ns:].T
return Xs_new, Xt_new ```
Example #23
```def visualizedistances(data, figname=None):
D, L, N = data
sorted_indexes = np.argsort(L[:,0])

D2 = D[sorted_indexes, :]
D2 = D2[:, sorted_indexes]

plt.cla()
plt.clf()
plt.close()

plt.imshow(D2, cmap=plt.cm.gray)
plt.title('Distance matrix')
plt.savefig(figname, bbox_inches='tight') ```
Example #24
```def add_noise_python(words, dropout=0.1, k=3):
"""Applies the noise model in input words.

Args:
words: A numpy vector of word ids.
dropout: The probability to drop words.
k: Maximum distance of the permutation.

Returns:
A noisy numpy vector of word ids.
"""

def _drop_words(words, probability):
"""Drops words with the given probability."""
length = len(words)
keep_prob = np.random.uniform(size=length)
keep = np.random.uniform(size=length) > probability
if np.count_nonzero(keep) == 0:
ind = np.random.randint(0, length)
keep[ind] = True
words = np.take(words, keep.nonzero())[0]
return words

def _rand_perm_with_constraint(words, k):
"""Randomly permutes words ensuring that words are no more than k positions
away from their original position."""
length = len(words)
offset = np.random.uniform(size=length) * (k + 1)
new_pos = np.arange(length) + offset
return np.take(words, np.argsort(new_pos))

words = _drop_words(words, dropout)
words = _rand_perm_with_constraint(words, k)
return words ```
Example #25
```def computeIoU(self, imgId, catId):
p = self.params
if p.useCats:
gt = self._gts[imgId,catId]
dt = self._dts[imgId,catId]
else:
gt = [_ for cId in p.catIds for _ in self._gts[imgId,cId]]
dt = [_ for cId in p.catIds for _ in self._dts[imgId,cId]]
if len(gt) == 0 and len(dt) ==0:
return []
inds = np.argsort([-d['score'] for d in dt], kind='mergesort')
dt = [dt[i] for i in inds]
if len(dt) > p.maxDets[-1]:
dt=dt[0:p.maxDets[-1]]

if p.iouType == 'segm':
g = [g['segmentation'] for g in gt]
d = [d['segmentation'] for d in dt]
elif p.iouType == 'bbox':
g = [g['bbox'] for g in gt]
d = [d['bbox'] for d in dt]
else:
raise Exception('unknown iouType for iou computation')

# compute iou between each dt and gt region
iscrowd = [int(o['iscrowd']) for o in gt]
return ious ```
Example #26
```def rank_roidb_ratio(roidb):
# rank roidb based on the ratio between width and height.
ratio_large = 2  # largest ratio to preserve.
ratio_small = 0.5  # smallest ratio to preserve.

ratio_list = []
for i in range(len(roidb)):
width = roidb[i]['width']
height = roidb[i]['height']
ratio = width / float(height)

if cfg.TRAIN.ASPECT_CROPPING:
if ratio > ratio_large:
roidb[i]['need_crop'] = 1
ratio = ratio_large
elif ratio < ratio_small:
roidb[i]['need_crop'] = 1
ratio = ratio_small
else:
roidb[i]['need_crop'] = 0
else:
roidb[i]['need_crop'] = 0

ratio_list.append(ratio)

ratio_list = np.array(ratio_list)
ratio_index = np.argsort(ratio_list)
return ratio_list[ratio_index], ratio_index ```
Example #27
 Source File: online.py    From contextualbandits with BSD 2-Clause "Simplified" License 5 votes
```def topN(self, X, n):
"""
Get top-N ranked actions for each observation

Note
----
This method will rank choices/arms according to what the policy
dictates - it is not an exploitation-mode rank, so if e.g. there are
random choices for some observations, there will be random ranks in here.

Parameters
----------
X : array (n_samples, n_features)
New observations for which to rank actions according to this policy.
n : int
Number of top-ranked actions to output

Returns
-------
topN : array(n_samples, n)
The top-ranked actions for each observation
"""
assert n >= 1
if isinstance(n, float):
n = int(n)
assert isinstance(n, int)
if n > self.nchoices:
raise ValueError("'n' cannot be greater than 'nchoices'.")
X = _check_X_input(X)
scores = self._score_matrix(X)
if n == self.nchoices:
topN = np.argsort(scores, axis=1)
else:
topN = topN_byrow(scores, n, self.njobs)
return self._name_arms(topN) ```
Example #28
 Source File: graphTools.py    From graph-neural-networks with GNU General Public License v3.0 5 votes
```def perm_adjacency(A, indices):
# Function written by M. Defferrard, taken verbatim, from
# https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L242
"""
Permute adjacency matrix, i.e. exchange node ids,
so that binary unions form the clustering tree.
"""
if indices is None:
return A

M, M = A.shape
Mnew = len(indices)
assert Mnew >= M
A = A.tocoo()

# Add Mnew - M isolated vertices.
if Mnew > M:
rows = scipy.sparse.coo_matrix((Mnew-M,    M), dtype=np.float32)
cols = scipy.sparse.coo_matrix((Mnew, Mnew-M), dtype=np.float32)
A = scipy.sparse.vstack([A, rows])
A = scipy.sparse.hstack([A, cols])

# Permute the rows and the columns.
perm = np.argsort(indices)
A.row = np.array(perm)[A.row]
A.col = np.array(perm)[A.col]

# assert np.abs(A - A.T).mean() < 1e-9
assert type(A) is scipy.sparse.coo.coo_matrix
return A ```
Example #29
```def sort_by_field(boxlist, field, order=SortOrder.DESCEND):
"""Sort boxes and associated fields according to a scalar field.

A common use case is reordering the boxes according to descending scores.

Args:
boxlist: BoxList holding N boxes.
field: A BoxList field for sorting and reordering the BoxList.
order: (Optional) 'descend' or 'ascend'. Default is descend.

Returns:
sorted_boxlist: A sorted BoxList with the field in the specified order.

Raises:
ValueError: if specified field does not exist or is not of single dimension.
ValueError: if the order is not either descend or ascend.
"""
if not boxlist.has_field(field):
raise ValueError('Field ' + field + ' does not exist')
if len(boxlist.get_field(field).shape) != 1:
raise ValueError('Field ' + field + 'should be single dimension.')
if order != SortOrder.DESCEND and order != SortOrder.ASCEND:
raise ValueError('Invalid sort order')

field_to_sort = boxlist.get_field(field)
sorted_indices = np.argsort(field_to_sort)
if order == SortOrder.DESCEND:
sorted_indices = sorted_indices[::-1]
return gather(boxlist, sorted_indices) ```
Example #30
 Source File: graphTools.py    From graph-neural-networks with GNU General Public License v3.0 5 votes
```def computeGFT(S, order = 'no'):
"""
computeGFT: Computes the frequency basis (eigenvectors) and frequency
coefficients (eigenvalues) of a given GSO

Input:

S (np.array): graph shift operator matrix
order (string): 'no', 'increasing', 'totalVariation' chosen order of
frequency coefficients (default: 'no')

Output:

E (np.array): diagonal matrix with the frequency coefficients
(eigenvalues) in the diagonal
V (np.array): matrix with frequency basis (eigenvectors)
"""
# Check the correct order input
assert order == 'totalVariation' or order == 'no' or order == 'increasing'
# Check the matrix is square
assert S.shape[0] == S.shape[1]
# Check if it is symmetric
symmetric = np.allclose(S, S.T, atol = zeroTolerance)
# Then, compute eigenvalues and eigenvectors
if symmetric:
e, V = np.linalg.eigh(S)
else:
e, V = np.linalg.eig(S)
# Sort the eigenvalues by the desired error:
if order == 'totalVariation':
eMax = np.max(e)
sortIndex = np.argsort(np.abs(e - eMax))
elif order == 'increasing':
sortIndex = np.argsort(np.abs(e))
else:
sortIndex = np.arange(0, S.shape[0])
e = e[sortIndex]
V = V[:, sortIndex]
E = np.diag(e)
return E, V ```