本文整理匯總了Python中numpy.argsort方法的典型用法代碼示例。如果您正苦於以下問題:Python numpy.argsort方法的具體用法?Python numpy.argsort怎麽用?Python numpy.argsort使用的例子?那麽, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在類numpy
的用法示例。
在下文中一共展示了numpy.argsort方法的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Python代碼示例。
示例1: classical_mds
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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)
示例2: _peaks1D
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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---------------------#
示例3: cmap
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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)))
示例4: k_nearest_neighbor
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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
示例5: about0
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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):
LOGGER.info("Running 'about0' mode step %i"%(stepIdx))
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
# ############ RUN ROTATION ABOUT SYMM AXIS 1 ############ #
示例6: about1
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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):
LOGGER.info("Running 'about1' mode step %i"%(stepIdx))
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
# ############ RUN ROTATION ABOUT SYMM AXIS 2 ############ #
示例7: about2
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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):
LOGGER.info("Running 'about2' mode step %i"%(stepIdx))
ENGINE.run(numberOfSteps=nsteps, saveFrequency=nsteps)
# ############ RUN TRANSLATION ALONG SYMM AXIS 0 ############ #
示例8: along0
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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 ############ #
示例9: along2
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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 ############ #
示例10: shrink
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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 ###################################
示例11: forward_ocr
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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)
示例12: test_lwlr
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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))
示例13: plot_rhodelta_rho
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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')
示例14: calc_pr
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
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
示例15: _get_room_dimensions
# 需要導入模塊: import numpy [as 別名]
# 或者: from numpy import argsort [as 別名]
def _get_room_dimensions(file_name, resolution, origin, flip=False):
if fu.exists(file_name):
a = utils.load_variables(file_name)['room_dimension']
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