本文整理汇总了Python中theano.tensor.sort.sort函数的典型用法代码示例。如果您正苦于以下问题：Python sort函数的具体用法？Python sort怎么用？Python sort使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了sort函数的12个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_grad_negative_axis_3d
def test_grad_negative_axis_3d(self):
data = np.random.rand(2, 3, 4).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -1), [data])
data = np.random.rand(2, 3, 4).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -2), [data])
data = np.random.rand(2, 3, 4).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -3), [data])示例2: test_grad_none_axis
def test_grad_none_axis(self):
data = np.random.rand(10).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, None), [data])
utt.verify_grad(lambda x: sort(x, 0), [data])
data = np.random.rand(2, 3).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, None), [data])示例3: test_grad_nonnegative_axis_4d
def test_grad_nonnegative_axis_4d(self):
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, 0), [data])
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, 1), [data])
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, 2), [data])
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, 3), [data])示例4: test_sort
def test_sort(self):
x = tensor.matrix()
self._compile_and_check(
[x],
[sort(x)],
[np.random.randn(10, 40).astype(theano.config.floatX)],
SortOp)
self._compile_and_check(
[x],
[sort(x, axis=None)],
[np.random.randn(10, 40).astype(theano.config.floatX)],
SortOp)示例5: test_None
def test_None(self):
a = tensor.dmatrix()
l = sort(a, None)
f = theano.function([a], l)
gv = f(self.m_val)
gt = np.sort(self.m_val, None)
assert np.allclose(gv, gt)示例6: test3
def test3(self):
a = tensor.dvector()
w2 = sort(a)
f = theano.function([a], w2)
gv = f(self.v_val)
gt = np.sort(self.v_val)
assert np.allclose(gv, gt)示例7: test4
def test4(self):
a = tensor.dmatrix()
axis = tensor.scalar()
l = sort(a, axis, "mergesort")
f = theano.function([a, axis], l)
for axis_val in 0, 1:
gv = f(self.m_val, axis_val)
gt = np.sort(self.m_val, axis_val)
assert np.allclose(gv, gt)示例8: test2
def test2(self):
a = tensor.dmatrix()
axis = tensor.scalar()
w = sort(a, axis)
f = theano.function([a, axis], w)
for axis_val in 0, 1:
gv = f(self.m_val, axis_val)
gt = np.sort(self.m_val, axis_val)
utt.assert_allclose(gv, gt)示例9: test_grad_negative_axis
def test_grad_negative_axis(self):
# test 2D
data = np.random.rand(2, 3).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -1), [data])
data = np.random.rand(2, 3).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -2), [data])
# test 3D
data = np.random.rand(2, 3, 4).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -1), [data])
data = np.random.rand(2, 3, 4).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -2), [data])
data = np.random.rand(2, 3, 4).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -3), [data])
# test 4D
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -1), [data])
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -2), [data])
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -3), [data])
data = np.random.rand(2, 3, 4, 2).astype(theano.config.floatX)
utt.verify_grad(lambda x: sort(x, -4), [data])示例10: test1
def test1(self):
a = tensor.dmatrix()
w = sort(a)
f = theano.function([a], w)
assert np.allclose(f(self.m_val), np.sort(self.m_val))示例11: sort
def sort(self, axis=-1, kind='quicksort', order=None):
"""See `theano.tensor.sort`"""
from theano.tensor.sort import sort
return sort(self, axis, kind, order)示例12: __init__
def __init__(self, width, height, potentialInhibWidth, potentialInhibHeight,
desiredLocalActivity, minOverlap, centerInhib=1):
# Temporal Parameters
###########################################
# Specifies if the potential synapses are centered
# over the columns
self.centerInhib = centerInhib
self.width = width
self.height = height
self.potentialWidth = potentialInhibWidth
self.potentialHeight = potentialInhibHeight
self.areaKernel = self.potentialWidth * self.potentialHeight
self.desiredLocalActivity = desiredLocalActivity
self.minOverlap = minOverlap
# Store how much padding is added to the input grid
self.topPos_y = 0
self.bottomPos_y = 0
self.leftPos_x = 0
self.rightPos_x = 0
# Create theano variables and functions
############################################
# Create the theano function for calculating
# if the colInConvole matrix. This takes a vector
# storing an offset number and adds this to the input
# matrix if the element in the input matrix is greater then
# zero.
self.in_colPatMat = T.matrix(dtype='int32')
self.in_colAddVect = T.vector(dtype='int32')
self.in_colNegVect = T.vector(dtype='int32')
self.col_num3 = T.matrix(dtype='int32')
self.check_gtZero2 = T.switch(T.gt(self.in_colPatMat, 0),
(self.in_colPatMat +
self.in_colAddVect[self.col_num3] -
self.in_colNegVect[self.col_num3]+1),
0)
self.add_toConvolePat = function([self.in_colPatMat,
self.in_colAddVect,
self.in_colNegVect,
self.col_num3],
self.check_gtZero2,
allow_input_downcast=True)
# Create the theano function for calculating
# the addition of a small tie breaker value to each overlap value.
self.o_grid = T.matrix(dtype='float32')
self.tie_grid = T.matrix(dtype='float32')
self.add_vals = T.add(self.o_grid, self.tie_grid)
self.add_tieBreaker = function([self.o_grid, self.tie_grid],
self.add_vals,
on_unused_input='warn',
allow_input_downcast=True)
# Create the theano function for calculating
# the inputs to a column from an input grid.
self.kernalSize = (self.potentialHeight, self.potentialWidth)
# poolstep is how far to move the kernal in each direction.
self.poolstep = (1, 1)
# Create the theano function for calculating the overlaps of
# the potential columns that any column can inhibit.
self.neib_shape = T.as_tensor_variable(self.kernalSize)
self.neib_step = T.as_tensor_variable(self.poolstep)
self.pool_inp = T.tensor4('pool_input', dtype='float32')
self.pool_convole = images2neibs(self.pool_inp, self.neib_shape, self.neib_step, mode='valid')
self.pool_inputs = function([self.pool_inp],
self.pool_convole,
on_unused_input='warn',
allow_input_downcast=True)
# Create the theano function for calculating
# the sorted vector of overlaps for each columns inhib overlaps
self.o_mat = tensor.dmatrix()
#self.so_mat = tensor.dmatrix()
self.axis = tensor.scalar()
self.arg_sort = sort(self.o_mat, self.axis, "quicksort")
self.sort_vect = function([self.o_mat, self.axis], self.arg_sort)
# Create the theano function for calculating
# the minOverlap from the sorted vector of overlaps for each column.
# This function takes a vector of indicies indicating where the
# minLocalActivity resides for each row in the matrix.
# Note: the sorted overlap matrix goes from low to highest so use neg index.
self.min_OIndex = T.vector(dtype='int32')
self.s_ColOMat = T.matrix(dtype='float32')
self.row_numVect2 = T.vector(dtype='int32')
self.get_indPosVal = self.s_ColOMat[self.row_numVect2, -self.min_OIndex]
self.get_minLocAct = function([self.min_OIndex,
self.s_ColOMat,
self.row_numVect2],
self.get_indPosVal,
allow_input_downcast=True
)
# Create the theano function for calculating
# if a column should be active or not based on whether it
# has an overlap greater then or equal to the minLocalActivity.
self.minLocalActivity = T.matrix(dtype='float32')
self.colOMat = T.matrix(dtype='float32')
self.check_gt_zero = T.switch(T.gt(self.colOMat, 0), 1, 0)
self.check_gteq_minLocAct = T.switch(T.ge(self.colOMat, self.minLocalActivity), self.check_gt_zero, 0)
#.........这里部分代码省略.........