我们从Python开源项目中，提取了以下38个代码示例，用于说明如何使用theano.tensor.argsort()。
def rbf_kernel(X0): XY = T.dot(X0, X0.transpose()) x2 = T.reshape(T.sum(T.square(X0), axis=1), (X0.shape[0], 1)) X2e = T.repeat(x2, X0.shape[0], axis=1) H = T.sub(T.add(X2e, X2e.transpose()), 2 * XY) V = H.flatten() # median distance h = T.switch(T.eq((V.shape[0] % 2), 0), # if even vector T.mean(T.sort(V)[ ((V.shape[0] // 2) - 1) : ((V.shape[0] // 2) + 1) ]), # if odd vector T.sort(V)[V.shape[0] // 2]) h = T.sqrt(0.5 * h / T.log(X0.shape[0].astype('float32') + 1.0)) / 2. Kxy = T.exp(-H / h ** 2 / 2.0) neighbors = T.argsort(H, axis=1)[:, 1] return Kxy, neighbors, h
def in_top_k(predictions, targets, k): '''Returns whether the `targets` are in the top `k` `predictions` # Arguments predictions: A tensor of shape batch_size x classess and type float32. targets: A tensor of shape batch_size and type int32 or int64. k: An int, number of top elements to consider. # Returns A tensor of shape batch_size and type int. output_i is 1 if targets_i is within top-k values of predictions_i ''' predictions_top_k = T.argsort(predictions)[:, -k:] result, _ = theano.map(lambda prediction, target: any(equal(prediction, target)), sequences=[predictions_top_k, targets]) return result # CONVOLUTIONS
def compile_eval_function(nnet): X = T.tensor4() y = T.ivector() # get prediciton by fully convolutional network prediction = lasagne.layers.get_output(nnet.dense3_conv_layer, deterministic=True, inputs=X) # get output scores on first dim # before flattening on 2dim and then get scores on second dim prediction = prediction.transpose((1, 0, 2, 3))\ .flatten(2).transpose((1, 0)) prediction = T.nnet.softmax(prediction) # spatial averaging prediction = T.mean(prediction, axis=0) # compute top1 and top5 accuracies sorted_pred = T.argsort(prediction) top1_acc = T.mean(T.eq(sorted_pred[-1], y), dtype='floatX') top5_acc = T.mean(T.any(T.eq(sorted_pred[-5:], T.shape_padright(y)), axis=1), dtype='floatX') return theano.function([X, y], [top1_acc, top5_acc])
def errors_top_x(self, y, num_top=5): if y.ndim != self.y_pred.ndim: raise TypeError('y should have the same shape as self.y_pred', ('y', y.type, 'y_pred', self.y_pred.type)) if num_top != 5: print('val errors from top %d' % num_top) ############TOP 5 VERSION########## # check if y is of the correct datatype if y.dtype.startswith('int'): # the T.neq operator returns a vector of 0s and 1s, where 1 # represents a mistake in prediction y_pred_top_x = T.argsort(self.p_y_given_x, axis=1)[:, -num_top:] y_top_x = y.reshape((y.shape[0], 1)).repeat(num_top, axis=1) return T.mean(T.min(T.neq(y_pred_top_x, y_top_x).astype('int8'), axis=1)) else: raise NotImplementedError()
def errors_top_x(self, y, num_top=5): if y.ndim != self.y_pred.ndim: raise TypeError('y should have the same shape as self.y_pred', ('y', y.type, 'y_pred', self.y_pred.type)) if num_top != 5: print 'val errors from top %d' % num_top ############TOP 5 VERSION########## # check if y is of the correct datatype if y.dtype.startswith('int'): # the T.neq operator returns a vector of 0s and 1s, where 1 # represents a mistake in prediction y_pred_top_x = T.argsort(self.p_y_given_x, axis=1)[:, -num_top:] y_top_x = y.reshape((y.shape[0], 1)).repeat(num_top, axis=1) # return T.mean(T.min( return T.neq(y_pred_top_x, y_top_x) # , axis=1)) else: raise NotImplementedError()
def in_top_k(predictions, targets, k): """Returns whether the `targets` are in the top `k` `predictions` # Arguments predictions: A tensor of shape batch_size x classess and type float32. targets: A tensor of shape batch_size and type int32 or int64. k: An int, number of top elements to consider. # Returns A tensor of shape batch_size and type int. output_i is 1 if targets_i is within top-k values of predictions_i """ predictions_top_k = T.argsort(predictions)[:, -k:] result, _ = theano.map(lambda prediction, target: any(equal(prediction, target)), sequences=[predictions_top_k, targets]) return result # CONVOLUTIONS
def _k_max_pooling(input, kmax): pool = input.dimshuffle(0, 2, 1, 3).flatten(ndim=3).dimshuffle(1,0,2).flatten(ndim=2).dimshuffle(1,0) neighborsArgSorted = T.argsort(pool, axis=1) yy = T.sort(neighborsArgSorted[:, -kmax:], axis=1).flatten() xx = T.repeat(T.arange(neighborsArgSorted.shape[0]), kmax) pool_kmax = pool[xx, yy] pool_kmax_shape = T.join(0, T.as_tensor([input.shape[0], input.shape[1], input.shape[3], kmax])) pooled_out = pool_kmax.reshape(pool_kmax_shape, ndim=4).dimshuffle(0, 1, 3, 2) return pooled_out
def k_max_pooling(input, kmax): nbatches, nchannels, nwords, ndim = input.shape[0], input.shape[1], input.shape[2], input.shape[3] x = input.dimshuffle(0,1,3,2) neighborsArgSorted = T.argsort(x, axis=3) ax0 = T.repeat(T.arange(nbatches), nchannels*ndim*kmax) ax1 = T.repeat(T.arange(nchannels), ndim * kmax).dimshuffle('x', 0) ax1 = T.repeat(ax1, nbatches, axis=0).flatten() ax2 = T.repeat(T.arange(ndim), kmax, axis=0).dimshuffle('x', 'x', 0) ax2 = T.repeat(ax2, nchannels, axis=1) ax2 = T.repeat(ax2, nbatches, axis=0).flatten() ax3 = T.sort(neighborsArgSorted[:,:,:,-kmax:], axis=3).flatten() pooled_out = x[ax0, ax1, ax2, ax3] pooled_out = pooled_out.reshape((nbatches, nchannels, ndim, kmax)).dimshuffle(0,1,3,2) return pooled_out
def dynamic_k_max_pooling(input, sent_sizes, k_max_factor, k_max_final): """ k_max_factor -- multiplied by sentence_sizes gives the value of kmax for each sentence """ # Unroll input into (batch_size x nchannels x nwords) x ndim nbatches, nchannels, nwords, ndim = input.shape[0], input.shape[1], input.shape[2], input.shape[3] x = input.dimshuffle(0,1,3,2) sent_sizes = T.cast(T.ceil(sent_sizes * k_max_factor), dtype='int32') sent_sizes = T.maximum(sent_sizes, k_max_final) # sent_sizes_matrix = T.repeat(sent_sizes, nwords, axis=1) sent_sizes_matrix = T.repeat(sent_sizes.dimshuffle(0, 'x'), nwords, axis=1) idx = T.arange(nwords).dimshuffle('x', 0) idx_matrix = T.repeat(idx, nbatches, axis=0) sent_sizes_mask = T.lt(idx_matrix, sent_sizes_matrix)[:,::-1] neighborsArgSorted = T.argsort(x, axis=3) neighborsArgSorted_masked = ((neighborsArgSorted + 1) * sent_sizes_mask.dimshuffle(0,'x','x',1)) - 1 neighborsArgSorted_masked_sorted = neighborsArgSorted_masked.sort(axis=3) nwords_max = T.cast(T.ceil(nwords * k_max_factor), 'int32') # print nwords_max.eval() neighborsArgSorted_masked_sorted_clipped = neighborsArgSorted_masked_sorted[:,:,:,-nwords_max:] ax0 = T.repeat(T.arange(nbatches), nchannels*ndim*nwords_max) ax1 = T.repeat(T.arange(nchannels), ndim * nwords_max).dimshuffle('x', 0) ax1 = T.repeat(ax1, nbatches, axis=0).flatten() ax2 = T.repeat(T.arange(ndim), nwords_max, axis=0).dimshuffle('x', 'x', 0) ax2 = T.repeat(ax2, nchannels, axis=1) ax2 = T.repeat(ax2, nbatches, axis=0).flatten() ax3 = neighborsArgSorted_masked_sorted_clipped.flatten() pooled_out = x[ax0, ax1, ax2, ax3] pooled_out = pooled_out.reshape((nbatches, nchannels, ndim, nwords_max)).dimshuffle(0,1,3,2) return pooled_out
def apply(self, y_hat): # reshape 1d vector to 2d matrix y_hat_2d = y_hat.reshape((y_hat.shape[0]/self.examples_group_size, self.examples_group_size)) #y_hat_2d = tt.printing.Print("Y hat 2d in correct rank: ")(y_hat_2d) # sort each group by relevance # we sort the responses in decreasing order, that is why we multiply y_hat by -1 sorting_indices = tt.argsort(-1 * y_hat_2d, axis=1) #sorting_indices = tt.printing.Print("sorting indices in correct rank: ")(sorting_indices) # check where is the ground truth whose index should be 0 in the original array correct_rank = tt.argmin(sorting_indices, axis=1) + 1 #correct_rank = tt.printing.Print("correct rank: ")(correct_rank) correct_rank.name = "correct_rank" return correct_rank
def kmaxpooling(input,input_shape,k): sorted_values = T.argsort(input,axis=3) topmax_indexes = sorted_values[:,:,:,-k:] # sort indexes so that we keep the correct order within the sentence topmax_indexes_sorted = T.sort(topmax_indexes) #given that topmax only gives the index of the third dimension, we need to generate the other 3 dimensions dim0 = T.arange(0,input_shape[0]).repeat(input_shape[1]*input_shape[2]*k) dim1 = T.arange(0,input_shape[1]).repeat(k*input_shape[2]).reshape((1,-1)).repeat(input_shape[0],axis=0).flatten() dim2 = T.arange(0,input_shape[2]).repeat(k).reshape((1,-1)).repeat(input_shape[0]*input_shape[1],axis=0).flatten() dim3 = topmax_indexes_sorted.flatten() return input[dim0,dim1,dim2,dim3].reshape((input_shape[0], input_shape[1], input_shape[2], k))
def top_n_align(self, n): """ :param n: :return: the top n relevant aglign index and respect align score, and the minimum align """ align_index = T.argsort(self.align, axis=0) align_order = T.sort(self.align, axis=0) return align_index[-n:], align_order[align_index[-n:], T.arange(align_order.shape[1])], align_order[0, :]
def get_analogy_prediction_model(embeddings, emb_size, vocab_size): # The eval feeds three vectors of word ids for a, b, c, each of # which is of size bsz, where bsz is the number of analogies we want to # evaluate in one batch. analogy_a = T.ivector('analogy_a') analogy_b = T.ivector('analogy_b') analogy_c = T.ivector('analogy_c') # Each row of a_emb, b_emb, c_emb is a word's embedding vector. a_emb = embeddings[analogy_a] # a's embs b_emb = embeddings[analogy_b] # b's embs c_emb = embeddings[analogy_c] # c's embs # We expect that d's embedding vectors on the unit hyper-sphere is # near: c_emb + (b_emb - a_emb), which has the shape [bsz, emb_size]. target = c_emb + (b_emb - a_emb) # Compute cosine distance between each pair of target and vocab. # dist has shape [bsz, vocab_size]. dist = T.dot(target, embeddings.T) # For each question (row in dist), find the top 4 words. pred_idx = T.argsort(dist, axis=1)[:, -4:] prediction_fn = theano.function([analogy_a, analogy_b, analogy_c], pred_idx) return prediction_fn
def errors_top_x(self, y, num_top=5): if y.ndim != self.y_pred.ndim: raise TypeError('y should have the same shape as self.y_pred', ('y', y.type, 'y_pred', self.y_pred.type)) # check if y is of the correct datatype if y.dtype.startswith('int'): # the T.neq operator returns a vector of 0s and 1s, where 1 # represents a mistake in prediction y_pred_top_x = T.argsort(self.p_y_given_x, axis=1)[:, -num_top:] y_top_x = y.reshape((y.shape[0], 1)).repeat(num_top, axis=1) return T.mean(T.min(T.neq(y_pred_top_x, y_top_x), axis=1)) else: raise NotImplementedError()
def kmax_pool_unroll(): pool = input.dimshuffle(0, 2, 1, 3).flatten(ndim=3).dimshuffle(1,0,2).flatten(ndim=2) neighborsArgSorted = T.argsort(pool, axis=0)
def argsort(x, axis=-1): return T.argsort(x, axis)
def argtop_k(x, k=1): # top-k accuracy top = T.argsort(x, axis=-1) # (Theano cannot index with [..., -top_k:], we need to simulate that) top = top[[slice(None) for _ in range(top.ndim - 1)] + [slice(-k, None)]] top = top[(slice(None),) * (top.ndim - 1) + (slice(None, None, -1),)] return top
def get_output(self, input_, label, mask=None): """ This function overrides the parents' one. Computes the loss by model input_ion and real label. Parameters ---------- input_: TensorVariable an array of (batch size, input_ion). for accuracy task, "input_" is 2D matrix. label: TensorVariable an array of (batch size, answer) or (batchsize,) if label is a list of class labels. for classification, highly recommend second one. should make label as integer. mask: TensorVariable an array of (batchsize,) only contains 0 and 1. loss are summed or averaged only through 1. Returns ------- TensorVariable a symbolic tensor variable which is scalar. """ # do if mask is None: if self.top_k == 1: if label.ndim == 1: return T.mean(T.eq(T.argmax(input_, axis=-1), label)) elif label.ndim == 2: return T.mean(T.eq(T.argmax(input_, axis=-1), T.argmax(label, axis=-1))) else: raise ValueError() else: # TODO: not yet tested top_k_input_ = T.argsort(input_)[:, -self.top_k:] # sort by values and keep top k indices if label.ndim == 1: return T.mean(T.any(T.eq(top_k_input_, label), axis=-1)) elif label.ndim == 2: return T.mean(T.any(T.eq(top_k_input_, T.argmax(label,axis=-1)), axis=-1)) raise ValueError() else: if self.top_k == 1: if label.ndim == 1: return T.sum(T.eq(T.argmax(input_, axis=-1), label) * mask) / T.sum(mask) elif label.ndim == 2: return T.sum(T.eq(T.argmax(input_, axis=-1), T.argmax(label, axis=-1)) * mask) / T.sum(mask) else: raise ValueError() else: # TODO: not yet tested top_k_input_ = T.argsort(input_)[:, -self.top_k:] # sort by values and keep top k indices if label.ndim == 1: return T.sum(T.any(T.eq(top_k_input_, label), axis=-1) * mask) / T.sum(mask) elif label.ndim == 2: return T.sum(T.any(T.eq(top_k_input_, T.argmax(label,axis=-1)), axis=-1) * mask) / T.sum(mask) raise ValueError()
