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])

    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])

 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])

 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)

 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)

 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)

 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)

 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)

    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])

 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))

 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)

    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)
#.........这里部分代码省略.........