def add_to_cart(self, product): product_ = CRUD.retreive_name('"'+product+'"') print(product) if(util.check_if_exists(product, self.order_list)): index = util.get_index(product, self.order_list) self.order_qty[index] = self.Tracker.qty_change util.replace(index, self.Table_) s = str(index) else: self.order_list.append(product) self.order_qty.append(self.Tracker.qty_change) s = 'end' print(product_) qty = self.Tracker.qty_change price = util.wholesale_check(qty, product_) total = price * qty delta = self.Tracker.qty_change - self.Tracker.qty_ref stock = self.Tracker.qty_s - delta CRUD.update_stock(str(product), int(stock)) if(qty == 0): a = int(util.get_index(product, self.order_list)) name=self.order_list.pop(a) quan=self.order_qty.pop(a) # self.focus_item(a) # self.Table_.tree.delete(self.Table_.tree.selection()) else: product=product.replace(" ", "") product=(product+" "+str(qty)+" " + str(price) + " "+ str(total)) self.Table_.tree.insert('', s, values=(product)) total = sum(float(self.Table_.tree.set(item,3)) for item in self.Table_.tree.get_children()) self.totala.set(total)
def __setitem__(self, indices, expr): if not isinstance(indices, tuple): indices = (indices, ) indices = self.indices + indices index, bit, _ = util.get_index(self.tensor.shape, indices, 0) if not Stage.get_len(): raise TensorError( "Cannot set tensor elements without compute APIs") builder = Stage.get_current() if bit is None: builder.emit( _make.Store(self.tensor.buf.data, _make.Cast(self.tensor.dtype, expr), index)) elif isinstance(bit, slice): load = _make.Load(self.tensor.dtype, self.tensor.buf.data, index) expr = _make.SetSlice(load, expr, bit.start, bit.stop) builder.emit( _make.Store(self.tensor.buf.data, _make.Cast(self.tensor.dtype, expr), index)) else: load = _make.Load(self.tensor.dtype, self.tensor.buf.data, index) expr = _make.SetBit(load, expr, bit) builder.emit( _make.Store(self.tensor.buf.data, _make.Cast(self.tensor.dtype, expr), index))
def __setitem__(self, indices, expr): indices = util.CastRemover().mutate(indices) Stage.get_current().input_stages.add(self.last_update) Stage.get_current().lhs_tensors.add(self) if not isinstance(indices, tuple): indices = (indices, ) indices = util.CastRemover().mutate(indices) if len(indices) < len(self.shape): raise TensorError("Accessing a slice of tensor is not allowed") else: index, bit, _ = util.get_index(self.shape, indices, 0) if not Stage.get_len(): raise TensorError( "Cannot set tensor elements without compute APIs") builder = Stage.get_current() if bit is None: builder.emit( _make.Store(self.buf.data, _make.Cast(self.dtype, expr), index)) elif isinstance(bit, slice): load = _make.Load(self.tensor.dtype, self.tensor.buf.data, index) expr = _make.SetSlice(load, expr, bit.start, bit.stop) builder.emit( _make.Store(self.tensor.buf.data, _make.Cast(self.tensor.dtype, expr), index)) else: load = _make.Load(self.tensor.dtype, self.tensor.buf.data, index) expr = _make.SetBit(load, expr, bit) builder.emit( _make.Store(self.tensor.buf.data, _make.Cast(self.tensor.dtype, expr), index))
def OnDouble_listbox(self, event): widget = event.widget selection=widget.curselection() product=self._list[selection[0]] for i in range(0, len(product)): if (product[i]==')'): product=product[i+1:] break #value = widget.get(selection[0]) import re qty=(re.findall('\d+', self._list[selection[0]] )) qty=int(qty[0]) if(util.check_if_exists(product, self.order_list)): util.focus_item(util.get_index(product, self.order_list), self.Table_) qty_c = int(self.Table_.tree.item(self.Table_.tree.selection())['values'][1]) self.r = 0 else: qty_c = 1 self.r = 1 self.Tracker = quantity_change(False, qty-self.r, qty_c) quantity(1, self.root, self.body, self.Tracker) if (self.Tracker.confirm_flag == True): self.add_to_cart(product) s = self.Tracker.qty_s - (self.Tracker.qty_change - self.Tracker.qty_ref) self._list[selection[0]]=("("+str(s)+")"+product) self.list_var.set(self._list)
def main(): html = '' count = 0 MY_STOCKS = get_stocks() for item in MY_STOCKS: k, stock = item.split(':') # logging.info(stock) count += 1 try: report = stock_check(stock, name=k) html += report logging.info(stock) except Exception as exp: logging.exception(exp) if count % 4 == 0: time.sleep(60) INDEX_S = get_index() for ind in INDEX_S: name, index = ind.split(':') # logging.info(index) count += 1 try: report = index_check(index, name=name) html += report logging.info(index) except Exception as exp: logging.exception(exp) if count % 4 == 0: time.sleep(60) today = str(datetime.date.today()) html = get_complete_html(today, html) #print(html) theme = f'{today}**诊判报告' send_res_to_email(contents=html, theme=theme, content_type='html')
def _find_direct_speech(self, con): layer = self._arg_finder._iter_paula_layer( 'speechfinder.speechdcontent') for _, mark in layer: tokens = mark.ext start = get_index(tokens[0]) if start > con.start_index: continue end = get_index(tokens[-1]) if end < con.start_index or end < con.end_index: continue sent_idx = self._arg_finder._get_sent_index(tokens[0]) print sent_idx, con.sent_index if sent_idx == con.sent_index: # Connective is in the first sentence of the segment. return -1 return sent_idx return -1
def asnode(self): if len(self.indices) < len(self.tensor.shape): raise TensorError("Accessing a slice of tensor is not allowed") index, bit, _ = util.get_index(self.tensor.shape, self.indices, 0) if bit is None: return _make.Load(self.tensor.dtype, self.tensor.buf.data, index) elif isinstance(bit, slice): return _make.GetSlice( _make.Load(self.tensor.dtype, self.tensor.buf.data, index), bit.start, bit.stop) return _make.GetBit( _make.Load(self.tensor.dtype, self.tensor.buf.data, index), bit)
def left_hashtag_sentiment(aspect,pos_tweet,is_neg) : sentiment=['NULL']*3 sentiment[0]=aspect ctr=util.get_index(pos_tweet,aspect,0)-1 while(pos_tweet[ctr][1]!='#' and ctr>=0) : ctr=ctr-1 else : if(pos_tweet[ctr][1]=='#' and ctr>=0) : hashtag=pos_tweet[ctr][0] sentiment[1]=hashtag sentiment[2]=get_polarity(hashtag.lstrip('#'),is_neg) ctr=TERMINATE return sentiment
def right_hashtag_sentiment(aspect, pos_tweet, is_neg): sentiment = ['NULL'] * 3 sentiment[0] = aspect ctr = util.get_index(pos_tweet, aspect, 0) + 1 while (ctr >= 0 and ctr < len(pos_tweet) and pos_tweet[ctr][1] != '#'): ctr = ctr + 1 else: if (ctr >= 0 and ctr < len(pos_tweet) and pos_tweet[ctr][1] == '#'): hashtag = pos_tweet[ctr][0] sentiment[1] = hashtag sentiment[2] = get_polarity(hashtag.lstrip('#'), is_neg) ctr = TERMINATE return sentiment
def left_verb_sentiment(aspect,pos_tweet,is_neg) : sentiment=['NULL']*3 sentiment[0]=aspect ctr=util.get_index(pos_tweet,aspect,0)-1 while(pos_tweet[ctr][1]!='V' and ctr>=0) : ctr=ctr-1 else : if(pos_tweet[ctr][1]=='V' and ctr>=0) : verb=pos_tweet[ctr][0] sentiment[1]=verb sentiment[2]=get_polarity(verb,is_neg) ctr=TERMINATE return sentiment
def left_verb_sentiment(aspect, pos_tweet, is_neg): sentiment = ['NULL'] * 3 sentiment[0] = aspect ctr = util.get_index(pos_tweet, aspect, 0) - 1 while (pos_tweet[ctr][1] != 'V' and ctr >= 0): ctr = ctr - 1 else: if (pos_tweet[ctr][1] == 'V' and ctr >= 0): verb = pos_tweet[ctr][0] sentiment[1] = verb sentiment[2] = get_polarity(verb, is_neg) ctr = TERMINATE return sentiment
def shape_map(self, pred, method): '''method can be one of ['max', 'mean', 'max_pca', 'mean_pca']''' if method == 'max': shape = vectorize(get_index(pred)) shape = shape * 4 elif method == 'mean': shape = vectorize(get_index_mean(pred)) shape = shape * 4 elif method == 'max_pca': shape = vectorize(get_index(pred)) shape = shape * 4 shape = self.pca_noise_reduction(shape) elif method == 'mean_pca': shape = vectorize(get_index_mean(pred)) shape = shape * 4 shape_pca = self.pca_noise_reduction(shape) if p.debug: show_predict(self.img, shape) show_predict(self.img, shape_pca) else: print "Unknown method: ", method exit(0) return shape
def shape_map(self, pred, method): '''method can be one of ['max', 'mean', 'max_pca', 'mean_pca']''' if method == 'max': shape = vectorize(get_index(pred)) shape = shape * 4 elif method == 'mean': shape = vectorize(get_index_mean(pred)) shape = shape * 4 elif method == 'max_pca': shape = vectorize(get_index(pred)) shape = shape * 4 shape = self.pca_noise_reduction(shape) elif method == 'mean_pca': shape = vectorize(get_index_mean(pred)) shape = shape * 4 shape_pca = self.pca_noise_reduction(shape) if p.debug: show_predict(self.img, shape) show_predict(self.img, shape_pca) else: print "Unknown method: ", method exit(0) return shape
def aspect_sentiment(aspects,pos_tweets) : nsentiments=[] sentiments=[] aspect_senti=[] for i in range(0,len(aspects)) : for j in range(0,len(pos_tweets)) : if util.get_index(pos_tweets[j],aspects[i][0],0)!=-1 : sentiments.append(get_sentiment(aspects[i][0],pos_tweets[j])) nsentiments=[sentiment for sentiment in sentiments if sentiment!=[] ] polarity=classify_sentiment(nsentiments) x=["NULL"]*2 x[0]=aspects[i][0] x[1]=polarity aspect_senti.append(x) return aspect_senti
def _find_right_paren(self, con, left_paren): right_paren = self.PARENS[left_paren] for i in xrange(con.sent_index, len(self._arg_finder._sents)): sent = self._arg_finder._sents[i] for token in sent.ext: strng = token.getString() if strng in self.PARENS: return -1 elif strng == right_paren: # Make sure that all parts of a (possibly discontinuous) # connective are included in the segment. if get_index(token) < con.end_index: return -1 return i return -1
def left_adjective_sentiment(aspect,pos_tweet,is_neg) : sentiment=['NULL']*3 sentiment[0]=aspect ctr=util.get_index(pos_tweet,aspect,0)-1 while(pos_tweet[ctr][1]!='A' and ctr>=0) : ctr=ctr-1 else : if(pos_tweet[ctr][1]=='A' and ctr>=0) : adj=pos_tweet[ctr][0] sentiment[1]=adj if util.is_in_file('lists/comparative-words.txt',adj,False) or util.is_in_file('lists/superlative-words.txt',adj,False) : sentiment[2]=switch(get_polarity(adj,is_neg)) else : sentiment[2]=get_polarity(adj,is_neg) ctr=TERMINATE return sentiment
def right_verb_sentiment(aspect,pos_tweet,is_neg) : sentiment=['NULL']*3 sentiment[0]=aspect ctr=util.get_index(pos_tweet,aspect,0)+1 while(ctr>=0 and ctr<len(pos_tweet) and pos_tweet[ctr][1]!='V') : ctr=ctr+1 else : if(ctr>=0 and ctr<len(pos_tweet) and pos_tweet[ctr][1]=='R') : verb=pos_tweet[ctr][0] sentiment[1]=verb if not(util.is_in_file('lists/copulative.txt',verb,False)) and not(util.is_in_file('lists/intensifier.txt',verb,False)) : sentiment[2]=get_polarity(verb,is_neg) else : sentiment[2]=str('0') ctr=TERMINATE return sentiment
def found_negation(aspect,pos_tweet,wsize=NEGATION_WINDOW): is_neg=False if len(pos_tweet)<wsize : wsize=len(pos_tweet) ind=util.get_index(pos_tweet,aspect,0) if ind<wsize : start=0 end=wsize-1 else : start=wsize-ind+1 end=ind for i in range(start,end+1): word=pos_tweet[i][0] if util.is_in_file('lists/negative-words.txt',word,False) or util.is_in_file('lists/swear-words.txt',word,False): is_neg=True return is_neg
def right_adjective_sentiment(aspect,pos_tweet,is_neg) : sentiment=['NULL']*3 sentiment[0]=aspect ctr=util.get_index(pos_tweet,aspect,0)+1 while(ctr>=0 and ctr<len(pos_tweet) and pos_tweet[ctr][1]!='A') : ctr=ctr+1 else : if(ctr>=0 and ctr<len(pos_tweet) and pos_tweet[ctr][1]=='A') : adj=pos_tweet[ctr][0] sentiment[1]=adj if not(util.is_in_file('lists/intensifier.txt',adj,False)) : if util.is_in_file('lists/comparative-words.txt',adj,False) or util.is_in_file('lists/superlative-words.txt',adj,False) : sentiment[2]=switch(get_polarity(adj,is_neg)) else : sentiment[2]=get_polarity(adj,is_neg) ctr=TERMINATE return sentiment
def aspect_sentiment(aspects, pos_tweets): nsentiments = [] sentiments = [] aspect_senti = [] for i in range(0, len(aspects)): for j in range(0, len(pos_tweets)): if util.get_index(pos_tweets[j], aspects[i][0], 0) != -1: sentiments.append(get_sentiment(aspects[i][0], pos_tweets[j])) nsentiments = [ sentiment for sentiment in sentiments if sentiment != [] ] polarity = classify_sentiment(nsentiments) x = ["NULL"] * 2 x[0] = aspects[i][0] x[1] = polarity aspect_senti.append(x) return aspect_senti
def shape_map_all(self, pred): shapes = [] shape_max = vectorize(get_index(pred)) shape_max = shape_max * 4 shape_max_pca = self.pca_noise_reduction(shape_max) shape_mean = vectorize(get_index_mean(pred)) shape_mean = shape_mean * 4 shape_mean_pca = self.pca_noise_reduction(shape_mean) shapes.append(shape_max) shapes.append(shape_max_pca) shapes.append(shape_mean) shapes.append(shape_mean_pca) if p.debug: show_predict(self.img, shape_max) show_predict(self.img, shape_max_pca) show_predict(self.img, shape_mean) show_predict(self.img, shape_mean_pca) return shapes
def found_negation(aspect, pos_tweet, wsize=NEGATION_WINDOW): is_neg = False if len(pos_tweet) < wsize: wsize = len(pos_tweet) ind = util.get_index(pos_tweet, aspect, 0) if ind < wsize: start = 0 end = wsize - 1 else: start = wsize - ind + 1 end = ind for i in range(start, end + 1): word = pos_tweet[i][0] if util.is_in_file('lists/negative-words.txt', word, False) or util.is_in_file( 'lists/swear-words.txt', word, False): is_neg = True return is_neg
def left_adjective_sentiment(aspect, pos_tweet, is_neg): sentiment = ['NULL'] * 3 sentiment[0] = aspect ctr = util.get_index(pos_tweet, aspect, 0) - 1 while (pos_tweet[ctr][1] != 'A' and ctr >= 0): ctr = ctr - 1 else: if (pos_tweet[ctr][1] == 'A' and ctr >= 0): adj = pos_tweet[ctr][0] sentiment[1] = adj if util.is_in_file('lists/comparative-words.txt', adj, False) or util.is_in_file( 'lists/superlative-words.txt', adj, False): sentiment[2] = switch(get_polarity(adj, is_neg)) else: sentiment[2] = get_polarity(adj, is_neg) ctr = TERMINATE return sentiment
def right_verb_sentiment(aspect, pos_tweet, is_neg): sentiment = ['NULL'] * 3 sentiment[0] = aspect ctr = util.get_index(pos_tweet, aspect, 0) + 1 while (ctr >= 0 and ctr < len(pos_tweet) and pos_tweet[ctr][1] != 'V'): ctr = ctr + 1 else: if (ctr >= 0 and ctr < len(pos_tweet) and pos_tweet[ctr][1] == 'R'): verb = pos_tweet[ctr][0] sentiment[1] = verb if not (util.is_in_file('lists/copulative.txt', verb, False)) and not (util.is_in_file( 'lists/intensifier.txt', verb, False)): sentiment[2] = get_polarity(verb, is_neg) else: sentiment[2] = str('0') ctr = TERMINATE return sentiment
def shape_map_all(self, pred): shapes = [] shape_max = vectorize(get_index(pred)) shape_max = shape_max * 4 shape_max_pca = self.pca_noise_reduction(shape_max) shape_mean = vectorize(get_index_mean(pred)) shape_mean = shape_mean * 4 shape_mean_pca = self.pca_noise_reduction(shape_mean) shapes.append(shape_max) shapes.append(shape_max_pca) shapes.append(shape_mean) shapes.append(shape_mean_pca) if p.debug: show_predict(self.img, shape_max) show_predict(self.img, shape_max_pca) show_predict(self.img, shape_mean) show_predict(self.img, shape_mean_pca) return shapes
def _find_left_paren(self, sents, con): frontier = max( 0, min(con.sent_index - len(sents), con.sent_index - self.MAX_LOOKBEHIND)) for i in xrange(con.sent_index - 1, frontier - 1, -1): sent = self._arg_finder._sentences[i].ext for j in xrange(len(sent) - 1, -1, -1): token = sent[j] strng = token.getString() if strng in self.RIGHT_PARENS: return -1, None elif strng in self.PARENS: # Make sure that all parts of a (possibly discontinuous) # connective are included in the segment. if get_index(token) > con.start_index: return -1, None return i, strng return -1, None
def right_adjective_sentiment(aspect, pos_tweet, is_neg): sentiment = ['NULL'] * 3 sentiment[0] = aspect ctr = util.get_index(pos_tweet, aspect, 0) + 1 while (ctr >= 0 and ctr < len(pos_tweet) and pos_tweet[ctr][1] != 'A'): ctr = ctr + 1 else: if (ctr >= 0 and ctr < len(pos_tweet) and pos_tweet[ctr][1] == 'A'): adj = pos_tweet[ctr][0] sentiment[1] = adj if not (util.is_in_file('lists/intensifier.txt', adj, False)): if util.is_in_file('lists/comparative-words.txt', adj, False) or util.is_in_file( 'lists/superlative-words.txt', adj, False): sentiment[2] = switch(get_polarity(adj, is_neg)) else: sentiment[2] = get_polarity(adj, is_neg) ctr = TERMINATE return sentiment
def find_first_zero(array, galloc=__default_alloca): idx = get_index(0, array) get_arr = galloc("array", __build_java_array_fun, array) return f"""int [] arr = {get_arr}();
def binarysearch(high, expected_mid=None): key = __get_key(expected_mid, high, __array) result = get_index(key, __array) return f"""int [] array = {get_array};
if __name__ == '__main__': # usage: python shift_exp.py prototxt model layername root # filelists outRoot prototxt = sys.argv[1] model = sys.argv[2] layername = sys.argv[3] root = sys.argv[4] filelists = sys.argv[5] outRoot = sys.argv[6] net = caffe.Net(prototxt, model, caffe.TEST) (filenames, bbxs) = get_filenames_bbx(filelists) index = range(len(filenames)) random.shuffle(index) for i in index: print i, filenames[i], bbxs[i][0], bbxs[i][1], bbxs[i][2], bbxs[i][3] img_crops = shift_exp(root, filenames[i], bbxs[i], outRoot) preds = get_preds_multiple(net, layername, img_crops) preds_shape = preds.shape preds = softmax(np.reshape(preds, (preds_shape[0]*preds_shape[1], \ preds_shape[2]*preds_shape[3]))) preds = np.reshape(preds, preds_shape) (hp, wp) = get_index(preds) hp = hp * 4 wp = wp * 4 for i in range(9): plt.subplot(3, 3, i + 1) plt.imshow(img_crops[i]) plt.plot(wp[i], hp[i], '.g', hold=True) plt.show()
for epoch in range(num_epochs): print("Epoch: {}/{}".format(epoch + 1, num_epochs)) epoch_loss = 0 h0, c0 = Variable(torch.zeros(1, size_batch, lstm_dim)), Variable( torch.zeros(1, size_batch, lstm_dim)) for batch in range(num_batches): # if((batch+1) % 50 == 0 or (batch+1) == num_batches): # print("Training on batch: {}/{}".format(batch+1,num_batches)) batch_begin = batch * size_batch batch_end = (batch + 1) * size_batch x_data = [] y_data = [] for i in range(batch_begin, batch_end): #x_data.append(util.convert_to_one_hot(words[i], words2int, vocab_size)) #caso one-hot x_data.append(util.get_index(words[i], words2int)) #caso indice per parola y_data.append(labels[i]) x_tensor = Variable(torch.FloatTensor(x_data)) y_tensor = Variable(torch.FloatTensor(y_data)) optimizer.zero_grad() y_prob, (hn, cn) = model(torch.unsqueeze(x_tensor, 1), (h0, c0)) loss = criterion(torch.squeeze(y_prob, 2), torch.unsqueeze(y_tensor, 1)) loss = torch.mul(class_weights, loss) loss = torch.mean(loss) loss.backward() optimizer.step() epoch_loss += loss.item()
if __name__ == '__main__': # usage: python shift_exp.py prototxt model layername root # filelists outRoot prototxt = sys.argv[1] model = sys.argv[2] layername = sys.argv[3] root = sys.argv[4] filelists = sys.argv[5] outRoot = sys.argv[6] net = caffe.Net(prototxt, model, caffe.TEST) (filenames, bbxs) = get_filenames_bbx(filelists) index = range(len(filenames)) random.shuffle(index) for i in index: print i, filenames[i], bbxs[i][0], bbxs[i][1], bbxs[i][2], bbxs[i][3] img_crops = shift_exp(root, filenames[i], bbxs[i], outRoot) preds = get_preds_multiple(net, layername, img_crops) preds_shape = preds.shape preds = softmax(np.reshape(preds, (preds_shape[0]*preds_shape[1], \ preds_shape[2]*preds_shape[3]))) preds = np.reshape(preds, preds_shape) (hp, wp) = get_index(preds) hp = hp * 4 wp = wp * 4 for i in range(9): plt.subplot(3, 3, i+1) plt.imshow(img_crops[i]) plt.plot(wp[i], hp[i],'.g', hold=True) plt.show()
def compute_body(name, lambda_ivs, fcompute, shape=(), dtype=None, tensor=None, attrs=OrderedDict()): """Create a stage and perform the computation. If `tensor` is `None`, no tensor is returned. Parameters ---------- name : str The name of the stage lambda_ivs : list of IterVar A list contains the iteration variables in the lambda function if exists fcompute : callable The computation rule shape : tuple, optional The output shape or the iteration domain dtype : Type, optional The data type of the output/updated tensor tensor : Tensor, optional The tensor to be updated. Create a new one if it is `None` Returns ------- Tensor or None """ var_list = [i.var for i in lambda_ivs] return_tensor = True if tensor is None else False with Stage(name, dtype, shape) as stage: if not return_tensor: stage.input_stages.add(tensor.last_update) else: tensor = Tensor(shape, stage._dtype, name, stage._buf) buffer_var = tensor._buf.data dtype = tensor.dtype shape = tensor.shape stage.stmt_stack.append([]) ret = fcompute(*var_list) print(dir(ret)) print(dir(ret.a)) print(dir(ret.b)) stage.lhs_tensors.add(tensor) for t in stage.lhs_tensors: t.last_update = stage stmt = None if ret is None: # replace all hcl.return_ with Store stmt indices = lambda_ivs index, _, _ = get_index(shape, indices, 0) stmt = stage.pop_stmt() stmt = ReplaceReturn(buffer_var, dtype, index).mutate(stmt) stmt = make_for(indices, stmt, 0) elif isinstance(ret, (TensorSlice, Scalar, _expr.Expr, numbers.Number)): indices = lambda_ivs index, _, _ = get_index(shape, indices, 0) stage.emit(_make.Store(buffer_var, _make.Cast(dtype, ret), index)) stmt = make_for(indices, stage.pop_stmt(), 0) elif isinstance(ret, Tensor): # reduction ret_ivs = [ _IterVar((0, ret.shape[i]), ret.name + "_i" + str(i), 0) for i in range(0, len(ret.shape)) ] non_reduce_ivs = [] indices = [] rid = 0 for iv in lambda_ivs: if iv.var.name[0] == "_": indices.append(ret_ivs[rid]) rid += 1 else: indices.append(iv) non_reduce_ivs.append(iv) if rid != len(ret.shape): raise APIError( "Incorrect number of reduction axes in lambda arguments") index, _, _ = get_index(shape, indices, 0) st = _make.Store(buffer_var, _make.Cast(dtype, ret[tuple(ret_ivs)]), index) stage.emit(make_for(ret_ivs, st, 0)) stmt = stage.pop_stmt() stage.input_stages.remove(stage) if non_reduce_ivs: stmt = make_for(non_reduce_ivs, stmt, 0) else: raise APIError("Unknown return type of the computation rule") # add attributes to the loop if isinstance(stmt, _stmt.For): stmt = _make.For(stmt.loop_var, stmt.min, stmt.extent, 0, 0, stmt.body, list(attrs.keys()), list(attrs.values())) stage.emit(stmt) stage.axis_list = indices + stage.axis_list if return_tensor: tensor._tensor = stage._op return tensor return None