def compute_shifts(stimuli, scale): """ Get shifts for given tuning bandwidth """ x = utils.get_population2(stimuli, npoints=npoints, kind='circular', scale=scale).astype( defaults._DEFAULT_FLOATX_NP).transpose( 0, 2, 3, 1) #transpose to bhwc start = timer() with tf.device('/gpu:0'): ctx = ContextualCircuit() ctx.run(x) #builds tf graph with shape of x end = timer() print(end - start) with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess: start = timer() if profile: #chrome://tracing run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() sess.run( tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) y = sess.run(ctx.out_O, feed_dict={ctx.X: x}, options=run_options, run_metadata=run_metadata) #Profiling tl = timeline.Timeline(run_metadata.step_stats) ctf = tl.generate_chrome_trace_format() with open('timeline.json', 'w') as f: f.write(ctf) else: sess.run( tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())) y = sess.run(ctx.out_O, feed_dict={ctx.X: x}) end = timer() print(end - start) #transpose x and y back to bchw x = x.transpose(0, 3, 1, 2) y = y.transpose(0, 3, 1, 2) # compute absolute and relative dshifts xdec = utils.decode(x[:, :, cpt[0], cpt[1]], axis=1, kind=decoder_type) cdec = utils.decode(y[:, :, cpt[0], cpt[1]], axis=1, kind=decoder_type) sdec = utils.decode(y[:, :, spt[0], spt[1]], axis=1, kind=decoder_type) dshift_a = cdec - xdec dshift_r = (cdec - sdec) / (cval - sval) return dshift_a, dshift_r
def adb_sync(args, serial=''): _prefix = ['adb -s %s' % serial] if serial else ['adb'] _command = ' '.join(_prefix + args) s = subprocess.Popen((str(_command)), stderr=(subprocess.PIPE), stdout=(subprocess.PIPE), shell=True) _out, _err = s.communicate() err = utils.decode(_err) out = utils.decode(_out) if s.returncode == 0: return (None, out) print('cmd : ', _command, 'adb err : ', err + out) return (err, None)
def runInThread(args, kwargs): _serial = kwargs['serial'] if 'serial' in kwargs.keys() else '' _prefix = ['adb -s %s' % _serial] if _serial else ['adb'] _command = ' '.join(_prefix + args) callback = kwargs['callback'] proc = subprocess.Popen((str(_command)), stderr=(subprocess.PIPE), stdout=(subprocess.PIPE), shell=True) _out, _err = proc.communicate() if proc.returncode == 0: out = utils.decode(_out) callback(None, out) else: err = utils.decode(_err) callback(err, None)
def GIoULoss(pred, target, anchor, weight=None): pred_boxes = decode(pred.reshape(-1, 4), anchor.reshape(-1, 4)) pred_x1 = pred_boxes[:, 0] pred_y1 = pred_boxes[:, 1] pred_x2 = pred_boxes[:, 2] pred_y2 = pred_boxes[:, 3] pred_x2 = torch.max(pred_x1, pred_x2) pred_y2 = torch.max(pred_y1, pred_y2) pred_area = (pred_x2 - pred_x1) * (pred_y2 - pred_y1) gt_boxes = decode(target.reshape(-1, 4), anchor.reshape(-1, 4)) target_x1 = gt_boxes[:, 0] target_y1 = gt_boxes[:, 1] target_x2 = gt_boxes[:, 2] target_y2 = gt_boxes[:, 3] target_area = (target_x2 - target_x1) * (target_y2 - target_y1) x1_intersect = torch.max(pred_x1, target_x1) y1_intersect = torch.max(pred_y1, target_y1) x2_intersect = torch.min(pred_x2, target_x2) y2_intersect = torch.min(pred_y2, target_y2) area_intersect = torch.zeros(pred_x1.size()).to(pred) mask = (y2_intersect > y1_intersect) * (x2_intersect > x1_intersect) area_intersect[mask] = (x2_intersect[mask] - x1_intersect[mask]) * ( y2_intersect[mask] - y1_intersect[mask]) x1_enclosing = torch.min(pred_x1, target_x1) y1_enclosing = torch.min(pred_y1, target_y1) x2_enclosing = torch.max(pred_x2, target_x2) y2_enclosing = torch.max(pred_y2, target_y2) area_enclosing = (x2_enclosing - x1_enclosing) * (y2_enclosing - y1_enclosing) + 1e-7 area_union = pred_area + target_area - area_intersect + 1e-7 ious = area_intersect / area_union gious = ious - (area_enclosing - area_union) / area_enclosing losses = 1 - gious if weight is not None and weight.sum() > 0: return losses * weight else: assert losses.numel() != 0 return losses
def _calc_be_invited(self, data, req, timer): """ """ inviter_id = utils.decode(req.invite_code, utils.INVITE_CODE_KEY) if inviter_id == "": inviter_id = 0 else: inviter_id = long(inviter_id) cache_proxy = DataProxy() #查询玩家所在房间人数 cache_proxy.search("user", inviter_id) defer = cache_proxy.execute() defer.addCallback(self._check_inviter_id, data, inviter_id, req, timer) return defer
def predict(model, pr_loader, do_plot=False): sample = pr_loader.get_random_sample() dim_sample = sample.unsqueeze(0) model.eval() output = model(dim_sample) tokens = output.softmax(2).argmax(2) tokens = tokens.squeeze(1).numpy() text = utils.decode(tokens[0], pr_loader.__get_chars__()) if do_plot: i = transforms.ToPILImage().__call__(sample) # i.save('my.png') plt.imshow(i) plt.show() return text
loss = criterion(preds, text, preds_size, length) # 后处理解码 if config.ATTENTION.ENABLE: _, preds = preds.max(1) index = 0 for label in labels: pre = "".join(str(preds[index:index + len(label)])) index += len(label) if pre == label: n_correct += 1 else: _, preds = preds.max(2) preds = preds.transpose(1, 0).contiguous().view(-1) sim_preds = decode(preds.data, preds_size.data, config.DICT, raw=False) for pred, target in zip(sim_preds, labels): if pred == target: n_correct += 1 # 抓一个batch来显示 if not config.ATTENTION.ENABLE: raw_preds = decode(preds.data, preds_size.data, config.DICT, raw=True)[:config.TEST.NUM_TEST_DISP] for raw_pred, pred, gt in zip(raw_preds, sim_preds, labels): print('%-20s => %-20s, gt: %-20s' % (raw_pred, pred, gt)) now_acc = n_correct * 1.0 / test_num print("best_acc:{} correct:{} total:{}".format(
def post_process(cfg, c_batch, box_batch, iou_batch, anchors, resized_size): total_boxes = [] for c_fpn, box_fpn, iou_fpn, anchor_fpn in zip(c_batch, box_batch, iou_batch, anchors): N, _, H, W = c_fpn.shape A = box_fpn.size(1) // 4 # 'A' means num_anchors per location C = c_fpn.size(1) // A c_fpn = permute_and_flatten(c_fpn, N, A, C, H, W) # shape: (n, num_anchor, 80) c_fpn = c_fpn.sigmoid() box_fpn = permute_and_flatten(box_fpn, N, A, 4, H, W) # shape: (n, num_anchor, 4) box_fpn = box_fpn.reshape(N, -1, 4) iou_fpn = permute_and_flatten(iou_fpn, N, A, 1, H, W) iou_fpn = iou_fpn.reshape(N, -1).sigmoid() # multiply classification and IoU to get the score score_fpn = (c_fpn * iou_fpn[:, :, None]).sqrt() # use class score to do the pre-threshold candi_i_fpn = c_fpn > cfg.nms_score_thre # TODO: if use score_fpn to do score threshold? nms_topk_fpn = candi_i_fpn.reshape(N, -1).sum(dim=1) nms_topk_fpn = nms_topk_fpn.clamp(max=cfg.nms_topk) results = [] for score, box, nms_topk, candi_i, size in zip(score_fpn, box_fpn, nms_topk_fpn, candi_i_fpn, resized_size): score = score[ candi_i] # TODO: too much thre is not elegant, too handcrafted score, topk_i = score.topk( nms_topk, sorted=False) # use score to get the topk candi_i = candi_i.nonzero()[topk_i, :] box_selected = box[candi_i[:, 0], :].reshape(-1, 4) anchor_selected = anchor_fpn.box[candi_i[:, 0], :].reshape(-1, 4) anchor_selected = anchor_selected.cuda() box_decoded = decode(box_selected, anchor_selected) boxlist = BoxList(box_decoded, size, mode='x1y1x2y2', label=candi_i[:, 1] + 1, score=score) boxlist.clip_to_image(remove_empty=False) boxlist.remove_small_box(min_size=0) results.append(boxlist) total_boxes.append(results) box_list_fpn_batch = list( zip(*total_boxes) ) # bind together the fpn box_lists which belong to the same batch box_list_batch = [cat_boxlist(aa) for aa in box_list_fpn_batch] return select_over_all_levels(cfg, box_list_batch)
def runInThread(): try: is_up_8_0 = True if self.apiLevel() > 25 else False _cmd = 'adb shell top -O RSS -d 1 ' if is_up_8_0 else 'adb shell top -m 50 -s rss -d 1' p = subprocess.Popen(_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) tmp_memory_total = 0 pkg_cpu = 0.0 while self.cpuHasRun and subprocess.Popen.poll(p) is None: output = utils.decode(p.stdout.readline().strip()) # print(output) if is_up_8_0 == False: r = re.search('K\\s+(\\d+)K', output) if r is not None: tmp_memory_total = tmp_memory_total + int( r.group(1)) if pkg in output: arr = output.split() if is_up_8_0 == False: pkg_cpu += float( arr[self._Adb__cpu_index].replace( '%', '')) self._props['cpu'] = '{}%'.format(pkg_cpu) elif 'CPU' in output: self._props['cpu'] = '{}%'.format(pkg_cpu) pkg_cpu = 0.0 if is_up_8_0 == False: self._props['total_memory'] = tmp_memory_total tmp_memory_total = 0 if not self._Adb__has_cpu_index: arr = output.split() for i in range(len(arr)): if 'CPU' in arr[i]: self._Adb__cpu_index = i self._Adb__has_cpu_index = True if 'RSS' in arr[i]: self._Adb__memory_index = i - 1 if is_up_8_0 else i else: if 'User' in output: r = is_up_8_0 or re.search( 'User\\s(\\d+)%[\\S\\s]*System\\s(\\d+)%', output) if r: r = list( map(lambda it: int(it), r.groups())) self._props['total_cpu'] = '{}%'.format( sum(r)) else: if 'user' in output: if is_up_8_0 and self._Adb__cpu_count is not None: rr = re.search('(\\d+)%cpu', output) if rr: self._Adb__cpu_count = int( rr.group(1)) / 100 r = re.search( '\\s(\\S+)%user[\\s\\S]*\\s(\\S+)%sys', output) if r: # r = list(map(lambda it: float(it), r.groups())) # self._props['total_cpu'] = '{}%'.format(sum(r)) r = list( map(lambda it: float(it), r.groups())) total = sum( r ) / self._Adb__cpu_count if self._Adb__cpu_count else sum( r) self._props['total_cpu'] = '{}%'.format( total) elif 'Mem:' in output and is_up_8_0: r = re.search('(\\d+)k\\sused', output) if r: self._props['total_memory'] = int( r.groups()[0]) elif 'CPU' in output: self._props['cpu'] = '{}%'.format(pkg_cpu) pkg_cpu = 0.0 if not self._Adb__has_cpu_index: arr = output.split() for i in range(len(arr)): if 'CPU' in arr[i]: self._Adb__cpu_index = i # print('self._Adb__cpu_index==%s'%self._Adb__cpu_index) self._Adb__has_cpu_index = True if 'RSS' in arr[i]: self._Adb__memory_index = i - 1 if is_up_8_0 else i else: if pkg in output: arr = output.split() _cpu = float( arr[self._Adb__cpu_index] ) / self._Adb__cpu_count if self._Adb__cpu_count else arr[ self._Adb__cpu_index] # print('{},{}'.format(pkg_cpu,_cpu)) pkg_cpu += _cpu # print(pkg_cpu) # pkg_cpu += float(arr[self._Adb__cpu_index].replace('%', '')) self._props['cpu'] = '{}%'.format(pkg_cpu) self.cpuHasRun = False p.stdout.close() p.kill() except Exception as e: try: self.cpuHasRun = False finally: e = None del e
def __call__(self, c_pred, box_pred, iou_pred, box_list_batch): # c_init_batch: (bs * num_anchor,), 0 for background, -1 for ignored # offset_init_batch: (bs * num_anchor, 4) # index_init_batch: (bs * num_anchor,), -1 for bakground, -2 for ignored self.anchor_cat = cat_boxlist(self.anchors) c_init_batch, offset_init_batch, index_init_batch = self.initial_preparation( box_list_batch) pos_i_init = torch.nonzero(c_init_batch > 0).reshape(-1) c_pred_f, box_pred_f, iou_pred_f, anchor_f = concat_fpn_pred( c_pred, box_pred, iou_pred, self.anchor_cat) if pos_i_init.numel() > 0: with torch.no_grad( ): # compute anchor scores (losses) for all anchors, gradient is not needed. c_loss = focal_loss_cuda(c_pred_f, c_init_batch, self.cfg.fl_gamma, self.cfg.fl_alpha) box_loss = self.GIoULoss(box_pred_f, offset_init_batch, anchor_f, weight=None) box_loss = box_loss[c_init_batch > 0].reshape(-1) box_loss_full = torch.full((c_loss.shape[0], ), fill_value=10000, device=c_loss.device) assert box_loss.max( ) < 10000, 'box_loss_full initial value error' box_loss_full[pos_i_init] = box_loss score_batch = c_loss.sum(dim=1) + box_loss_full assert not torch.isnan( score_batch).any() # all the elements should not be nan # compute labels and targets using PAA final_c_batch, final_offset_batch = self.compute_paa( box_list_batch, c_init_batch, score_batch, index_init_batch) pos_i_final = torch.nonzero(final_c_batch > 0).reshape(-1) num_pos = pos_i_final.numel() box_pred_f = box_pred_f[pos_i_final] final_offset_batch = final_offset_batch[pos_i_final] anchor_f = anchor_f[pos_i_final] iou_pred_f = iou_pred_f[pos_i_final] gt_boxes = decode(final_offset_batch, anchor_f) box_pred_decoded = decode(box_pred_f, anchor_f).detach() iou_gt = self.compute_ious(gt_boxes, box_pred_decoded) cls_loss = focal_loss_cuda(c_pred_f, final_c_batch.int(), self.cfg.fl_gamma, self.cfg.fl_alpha) box_loss = self.GIoULoss(box_pred_f, final_offset_batch, anchor_f, weight=iou_gt) box_loss = box_loss[final_c_batch[pos_i_final] > 0].reshape(-1) iou_pred_loss = self.iou_bce_loss(iou_pred_f, iou_gt) iou_gt_sum = iou_gt.sum().item() else: box_loss = box_pred_f.sum() category_loss = cls_loss.sum() / num_pos box_loss = box_loss.sum() / iou_gt_sum * self.cfg.box_loss_w iou_pred_loss = iou_pred_loss / num_pos * self.cfg.iou_loss_w return category_loss, box_loss, iou_pred_loss