def evalnet(net, signals, labels, sequences, epoch, plot_result={}): # net.eval() confusion_mat = np.zeros((opt.label, opt.label), dtype=int) for i in range(int(len(sequences) / opt.batchsize)): signal, label = transformer.batch_generator( signals, labels, sequences[i * opt.batchsize:(i + 1) * opt.batchsize]) signal = transformer.ToInputShape(signal, opt, test_flag=True) signal, label = transformer.ToTensor(signal, label, no_cuda=opt.no_cuda) with torch.no_grad(): out = net(signal) pred = torch.max(out, 1)[1] pred = pred.data.cpu().numpy() label = label.data.cpu().numpy() for x in range(len(pred)): confusion_mat[label[x]][pred[x]] += 1 recall, acc, sp, err, k = statistics.report(confusion_mat) plot_result['test'].append(err) heatmap.draw(confusion_mat, opt, name='current_test') print( 'epoch:' + str(epoch), ' macro-prec,reca,F1,err,kappa: ' + str(statistics.report(confusion_mat))) return plot_result, confusion_mat
def evalnet(net, signals, stages, epoch, plot_result={}): # net.eval() confusion_mat = np.zeros((opt.label, opt.label), dtype=int) for i, (signal, stage) in enumerate(zip(signals, stages), 1): signal = transformer.ToInputShape(signal, opt.model_name, test_flag=True) signal, stage = transformer.ToTensor(signal, stage, no_cuda=opt.no_cuda) with torch.no_grad(): out = net(signal) pred = torch.max(out, 1)[1] pred = pred.data.cpu().numpy() stage = stage.data.cpu().numpy() for x in range(len(pred)): confusion_mat[stage[x]][pred[x]] += 1 recall, acc, sp, err, k = statistics.result(confusion_mat) plot_result['test'].append(err) heatmap.draw(confusion_mat, opt.label_name, opt.label_name, name='test') print('recall,acc,sp,err,k: ' + str(statistics.result(confusion_mat))) return plot_result, confusion_mat
def statistics(mat, opt, logname, heatmapname): util.writelog( '------------------------------ ' + logname + ' result ------------------------------', opt, True) util.writelog( logname + ' -> macro-prec,reca,F1,err,kappa: ' + str(report(mat)), opt, True) util.writelog('confusion_mat:\n' + str(mat) + '\n', opt, True) heatmap.draw(mat, opt, name=heatmapname)
def c(data): global directionz, currentTarget, snelheid if img is None: return print currentTarget.__name__ targets = [x for x in data.blobs if currentTarget(getat(img, x))] heatmap.cooldown(target_heatmap) heatmap.draw(target_heatmap, targets) hm2 = 1 * target_heatmap hm2[hm2 < 80] = 0 f = cv.fromarray(hm2) hm_pub.publish(bridge.cv_to_imgmsg(f)) hm_enc_pub.publish("16SC1") twist = Twist() # When a dot in the activation matrix is high enough we start to fly towards this place if hm2.max() > 16: snelheid = 0 weights = np.apply_along_axis(np.sum, 0, hm2) if np.sum(hm2) > 30000: # found! target_heatmap[:] = 0 if currentTarget in nextTarget: currentTarget = nextTarget[currentTarget] else: # Start landing twist.linear.x = -.1 action.publish(twist) l = rospy.Publisher("/ardrone/land", Empty) l.publish(Empty()) print "found" currentTarget = finished loc = np.average(indexes, weights=weights)/len(indexes) # When the target if farther to the left or right, we turn faster # Print what direction we are going to fly towards if loc < .5: print "left (new)" else: print "right (new)" twist.linear.x = .05 twist.angular.z = .5 - loc else: snelheid = max(snelheid + .001, .05) twist.angular.z = snelheid action.publish(twist)
def evalnet(net, signals, stages, sequences, epoch, plot_result={}, mode='part'): # net.eval() if mode == 'part': transformer.shuffledata(signals, stages) signals = signals[0:int(len(stages) / 2)] stages = stages[0:int(len(stages) / 2)] confusion_mat = np.zeros((5, 5), dtype=int) for i, sequence in enumerate(sequences, 1): signal = transformer.ToInputShape(signals[sequence], opt.model_name, test_flag=True) signal, stage = transformer.ToTensor(signal, stages[sequence], no_cuda=opt.no_cuda) with torch.no_grad(): out = net(signal) pred = torch.max(out, 1)[1] pred = pred.data.cpu().numpy() stage = stage.data.cpu().numpy() for x in range(len(pred)): confusion_mat[stage[x]][pred[x]] += 1 if mode == 'part': plot_result['test'].append(statistics.result(confusion_mat)[0]) else: recall, acc, error = statistics.result(confusion_mat) plot_result['test'].append(recall) heatmap.draw(confusion_mat, name='test') print('test avg_recall:', '%.4f' % recall, 'avg_acc:', '%.4f' % acc, 'error:', '%.4f' % error) #util.writelog('epoch:'+str(epoch)+' test avg_recall:'+str(round(recall,4))+' avg_acc:'+str(round(acc,4))+' error:'+str(round(error,4))) return plot_result, confusion_mat
def c(data): global directionz, currentTarget, snelheid if img is None: return lights = [x for x in data.blobs if getat(img, x)[0] > 100] if lights: naar = min(lights, key=lambda x: x.y) twist = Twist() twist.linear.x = .1 if naar.x < 50: twist.angular.z = .7 directionz = 1 print "hard left" elif naar.y > WIDTH - 50: twist.angular.z = -.7 directionz = -1 print "hard right" elif naar.x < MIDPOINTX - 20: twist.angular.z = .3 directionz = 1 print "left" elif naar.x > MIDPOINTX + 20: twist.angular.z = -.3 directionz = -1 print "right" else: #twist.linear.x = .2 print "straight on" action.publish(twist) else: twist = Twist() twist.angular.z = directionz #action.publish(twist) #print "n/a" print currentTarget.__name__ targets = [x for x in data.blobs if currentTarget(getat(img, x))] heatmap.cooldown(target_heatmap) heatmap.draw(target_heatmap, targets) hm2 = 1 * target_heatmap hm2[hm2 < 80] = 0 f = cv.fromarray(hm2) #print f, dir(f), f.step, f.channels, f.cols, f.rows, f.width, f.height hm_pub.publish(bridge.cv_to_imgmsg(f)) hm_enc_pub.publish("16SC1") if targets: target = max(targets, key=lambda x: x.area) print target.area if target.area > 2500: #found! target_heatmap[:] = 0 # If we have a new target after this one, take the next target. Otherwise we start landing if currentTarget in nextTarget: currentTarget = nextTarget[currentTarget] else: # Start landing twist = Twist() twist.linear.x = -.1 action.publish(twist) l = rospy.Publisher("/ardrone/land", Empty) l.publish(Empty()) print "found!" currentTarget = finished twist = Twist() if hm2.max() > 16: weights = np.apply_along_axis(np.sum, 0, hm2) loc = np.average(indexes, weights=weights)/len(indexes) if loc < .5: print "left (new)" else: print "right (new)" twist.linear.x = .1 twist.angular.z = .5 - loc# - .5 action.publish(twist)
out = net(signal) loss = criterion(out, stage) pred = torch.max(out, 1)[1] optimizer.zero_grad() loss.backward() optimizer.step() pred = pred.data.cpu().numpy() stage = stage.data.cpu().numpy() for x in range(len(pred)): confusion_mat[stage[x]][pred[x]] += 1 if i % show_freq == 0: plot_result['train'].append( statistics.result(confusion_mat)[0]) heatmap.draw(confusion_mat, name='train') # plot_result=evalnet(net,signals_eval,stages_eval,plot_result,show_freq,mode = 'part') statistics.show(plot_result, epoch + i / (batch_length * 0.8)) confusion_mat[:] = 0 plot_result, confusion_mat = evalnet(net, signals, stages, test_sequences[fold], epoch + 1, plot_result, mode='all') confusion_mats.append(confusion_mat) # scheduler.step() if (epoch + 1) % opt.network_save_freq == 0:
def c(data): global directionz, currentTarget, snelheid if img is None: return lights = [x for x in data.blobs if getat(img, x)[0] > 100] if lights: naar = min(lights, key=lambda x: x.y) twist = Twist() twist.linear.x = .1 if naar.x < 50: twist.angular.z = .7 directionz = 1 print "hard left" elif naar.y > WIDTH - 50: twist.angular.z = -.7 directionz = -1 print "hard right" elif naar.x < MIDPOINTX - 20: twist.angular.z = .3 directionz = 1 print "left" elif naar.x > MIDPOINTX + 20: twist.angular.z = -.3 directionz = -1 print "right" else: #twist.linear.x = .2 print "straight on" action.publish(twist) else: twist = Twist() twist.angular.z = directionz #action.publish(twist) #print "n/a" print currentTarget.__name__ targets = [x for x in data.blobs if currentTarget(getat(img, x))] heatmap.cooldown(target_heatmap) heatmap.draw(target_heatmap, targets) hm2 = 1 * target_heatmap hm2[hm2 < 80] = 0 f = cv.fromarray(hm2) #print f, dir(f), f.step, f.channels, f.cols, f.rows, f.width, f.height hm_pub.publish(bridge.cv_to_imgmsg(f)) hm_enc_pub.publish("16SC1") if targets: target = max(targets, key=lambda x: x.area) print target.area if target.area > 2500: #found! target_heatmap[:] = 0 # If we have a new target after this one, take the next target. Otherwise we start landing if currentTarget in nextTarget: currentTarget = nextTarget[currentTarget] else: # Start landing twist = Twist() twist.linear.x = -.1 action.publish(twist) l = rospy.Publisher("/ardrone/land", Empty) l.publish(Empty()) print "found!" currentTarget = finished twist = Twist() if hm2.max() > 16: weights = np.apply_along_axis(np.sum, 0, hm2) loc = np.average(indexes, weights=weights) / len(indexes) if loc < .5: print "left (new)" else: print "right (new)" twist.linear.x = .1 twist.angular.z = .5 - loc # - .5 action.publish(twist)
out = net(signal) loss = criterion(out, label) pred = torch.max(out, 1)[1] optimizer.zero_grad() loss.backward() optimizer.step() pred = pred.data.cpu().numpy() label = label.data.cpu().numpy() for x in range(len(pred)): confusion_mat[label[x]][pred[x]] += 1 iter_cnt += 1 if iter_cnt % opt.plotfreq == 0: plot_result['train'].append( statistics.report(confusion_mat)[3]) heatmap.draw(confusion_mat, opt, name='current_train') statistics.plotloss( plot_result, epoch + i / (train_sequences.shape[1] / opt.batchsize), opt) confusion_mat[:] = 0 plot_result, confusion_mat_eval = evalnet(net, signals, labels, test_sequences[fold], epoch + 1, plot_result) confusion_mats.append(confusion_mat_eval) torch.save(net.cpu().state_dict(), os.path.join(opt.save_dir, 'last.pth')) if (epoch + 1) % opt.network_save_freq == 0: torch.save(
out = net(signal) loss = criterion(out, stage) pred = torch.max(out, 1)[1] optimizer.zero_grad() loss.backward() optimizer.step() pred = pred.data.cpu().numpy() stage = stage.data.cpu().numpy() for x in range(len(pred)): confusion_mat[stage[x]][pred[x]] += 1 if i % show_freq == 0: plot_result['train'].append(statistics.result(confusion_mat)[3]) heatmap.draw(confusion_mat, opt.label_name, opt.label_name, name='train') statistics.show(plot_result, epoch + i / (batch_length * 0.8)) confusion_mat[:] = 0 plot_result, confusion_mat = evalnet(net, signals_test, labels_test, epoch + 1, plot_result) confusion_mats.append(confusion_mat) # scheduler.step() torch.save(net.cpu().state_dict(), './checkpoints/last.pth') if (epoch + 1) % opt.network_save_freq == 0: torch.save( net.cpu().state_dict(), './checkpoints/' + opt.model_name + '_epoch' + str(epoch + 1) + '.pth') print('network saved.')