def application(netR, optimizer, data_loader, data_length, epoch): # 3.1 switch to training mode torch.cuda.synchronize() netR.eval() out_mse = 0.0 timer = time.time() for i, data in enumerate(tqdm(data_loader, 0)): if len(data[0]) == 1: continue torch.cuda.synchronize() # 3.1.1 load inputs and ground truth points = data points = points.cuda() inputs_level1, inputs_level1_center = group_points(points, opt) inputs_level1 = Variable(inputs_level1, requires_grad=False) inputs_level1_center = Variable(inputs_level1_center, requires_grad=False) # 3.1.2 compute output optimizer.zero_grad() estimation = netR(inputs_level1, inputs_level1_center) torch.cuda.synchronize() # 3.1.4 update training error outputs = estimation.data np.save('./offline/results/out%d.npy' % epoch, outputs.cpu()) # time taken torch.cuda.synchronize() timer = time.time() - timer timer = timer / data_length print('==> time to learn 1 sample = %f (ms)' % (timer * 1000)) # print mse out_mse = out_mse / data_length print('mean-square error of 1 sample: %f, #train_data = %d' % (out_mse, data_length)) return out_mse
def match(self, img, template=None, templatename=""): if not template is None: self.template=template else: if self.template is None: return #cv2.imwrite("test.png",template) #self.tempautolabels=[] templabel=[] self.templateheight,self.templatewidth,_=self.template.shape #run template matching, get minimum val gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) gray_template = cv2.cvtColor(self.template,cv2.COLOR_BGR2GRAY) res = cv2.matchTemplate(gray, gray_template, cv2.TM_CCOEFF_NORMED)#TM_SQDIFF_NORMED min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) # create threshold from min val, find where sqdiff is less than thresh min_thresh = self.accuracyslider.slideValue#.9# (min_val + 1e-6) * 1.5 match_locations = np.where(res >= min_thresh) match_locations = (np.array(match_locations).T).tolist() match_locations = group_points(match_locations,10) #get the defaults from the actionbar try: labeltext = self.controller.actionbar.classes[self.controller.actionbar.defaultmatch] labelcolor=hsv_to_rgb(self.controller.actionbar.colors[self.controller.actionbar.defaultmatch].slideValue/360,1,1) except: labeltext = "NONE" labelcolor=(0,0,0) for m in match_locations: l=label(self.world,self.controller,m[1],m[0],self.templatewidth,self.templateheight,labeltext,(0,255,0),accuracy=res[m[0]][m[1]]*100,template=templatename) #self.labels.append(l) #self.tempautolabels.append(l) templabel.append(l) #print(self.match_locations) self.predict_missing_boxes(labeltext,templabel,templatename=templatename)
points = [] for output_file in listdir((TEMP_PATH)): # open file with open('/'.join([TEMP_PATH, output_file]), 'rb') as of: # get reader reader = csv.reader(of, delimiter=':') # create new Point instance and keep in a list for rec in reader: points.append(Point(rec[0], rec[1])) print "[INFO] List of points before grouping" for p in points: print " %-5d : %-5d" % (p.x, p.y) # Perform point grouping grouped_points = group_points(points) print "[INFO] List of points after grouping" for p in grouped_points: print " %-5d : %-5d" % (p.x, p.y) # Tap according to groupped points for p in grouped_points: print "[INFO] Tapping at", "%-5d : %-5d" % (p.x, p.y) adb.tap(p.x, p.y)
torch.cuda.synchronize() netR.eval() test_mse = 0.0 test_wld_err = 0.0 timer = time.time() for i, data in enumerate(tqdm(test_dataloader, 0)): torch.cuda.synchronize() # 3.1 load inputs and targets points, volume_length, gt_pca, gt_xyz = data gt_pca = Variable(gt_pca, volatile=True).cuda() points, volume_length, gt_xyz = points.cuda(), volume_length.cuda( ), gt_xyz.cuda() # points: B * 1024 * 6 inputs_level1, inputs_level1_center = group_points(points, opt) inputs_level1, inputs_level1_center = Variable(inputs_level1, volatile=True), Variable( inputs_level1_center, volatile=True) # 3.2 compute output estimation = netR(inputs_level1, inputs_level1_center) loss = criterion(estimation, gt_pca) * opt.PCA_SZ torch.cuda.synchronize() test_mse = test_mse + loss.data[0] * len(points) # 3.3 compute error in world cs outputs_xyz = test_data.PCA_mean.expand(estimation.data.size(0), test_data.PCA_mean.size(1)) outputs_xyz = torch.addmm(outputs_xyz, estimation.data,
def main(args=None): parser = argparse.ArgumentParser(description = "Training") parser.add_argument('--batchSize', type=int, default=48, help='input batch size') parser.add_argument('--nepoch', type=int, default=80, help='number of epochs to train for') parser.add_argument('--INPUT_FEATURE_NUM', type=int, default = 8, help='number of input point features') parser.add_argument('--temperal_num', type=int, default = 5, help='number of input point features') parser.add_argument('--pooling', type=str, default='concatenation', help='how to aggregate temporal split features: vlad | concatenation | bilinear') parser.add_argument('--dataset', type=str, default='ntu60', help='how to aggregate temporal split features: ntu120 | ntu60') parser.add_argument('--weight_decay', type=float, default=0.0008, help='weight decay (SGD only)') parser.add_argument('--learning_rate', type=float, default=0.0005, help='learning rate at t=0') parser.add_argument('--momentum', type=float, default=0.9, help='momentum (SGD only)') parser.add_argument('--workers', type=int, default=0, help='number of data loading workers') parser.add_argument('--root_path', type=str, default='/UCLA_point/UCLA_vsize40_feature_2048_ff_rawdi_2', help='preprocess folder')# 3DV points path parser.add_argument('--depth_path', type=str, default='3DV_construction/UCLA_point/UCLA_bboxed_2048', help='raw_depth_png')# appearance points path parser.add_argument('--save_root_dir', type=str, default='results_ucla/UCLA_v40_MultiStream_rawdi2', help='output folder') parser.add_argument('--model', type=str, default = '', help='model name for training resume') parser.add_argument('--optimizer', type=str, default = '', help='optimizer name for training resume') parser.add_argument('--ngpu', type=int, default=1, help='# GPUs') parser.add_argument('--main_gpu', type=int, default=0, help='main GPU id') # CUDA_VISIBLE_DEVICES=0 python train.py parser.add_argument('--learning_rate_decay', type=float, default=1e-7, help='learning rate decay') parser.add_argument('--size', type=str, default='full', help='how many samples do we load: small | full') parser.add_argument('--SAMPLE_NUM', type=int, default = 2048, help='number of sample points') parser.add_argument('--Num_Class', type=int, default = 10, help='number of outputs') parser.add_argument('--knn_K', type=int, default = 64, help='K for knn search') parser.add_argument('--sample_num_level1', type=int, default = 512, help='number of first layer groups') parser.add_argument('--sample_num_level2', type=int, default = 128, help='number of second layer groups') parser.add_argument('--ball_radius', type=float, default=0.11, help='square of radius for ball query in level 1')#0.025 -> 0.05 for detph parser.add_argument('--ball_radius2', type=float, default=0.24, help='square of radius for ball query in level 2')# 0.08 -> 0.01 for depth opt = parser.parse_args() print (opt) torch.cuda.set_device(opt.main_gpu) opt.manualSeed = 1 random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) try: os.makedirs(opt.save_root_dir) except OSError: pass logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%Y/%m/%d %H:%M:%S', filename=os.path.join(opt.save_root_dir, 'print.log'), level=logging.INFO) logging.info('======================================================') os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3' torch.backends.cudnn.benchmark = True #torch.backends.cudnn.deterministic = True torch.cuda.empty_cache() data_train = NTU_RGBD(root_path = opt.root_path,opt=opt, test = False, Transform = True ) train_loader = DataLoader(dataset = data_train, batch_size = opt.batchSize, shuffle = True, drop_last = True) data_val = NTU_RGBD(root_path = opt.root_path, opt=opt, test = True, Transform = False ) val_loader = DataLoader(dataset = data_val, batch_size = 24) #net = netR = PointNet_Plus(opt) #netR = Attension_Point(opt) #netR = load_state_dict(torch.load()) netR.load_state_dict(torch.load('pointnet_para_44.pth'),strict = False) netR = torch.nn.DataParallel(netR).cuda() netR.cuda() print(netR) criterion = torch.nn.CrossEntropyLoss().cuda() optimizer = torch.optim.Adam(netR.parameters(), lr=opt.learning_rate, betas = (0.5, 0.999), eps=1e-06) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.5) for epoch in range(opt.nepoch): scheduler.step(epoch) # switch to train mode torch.cuda.synchronize() netR.train() acc = 0.0 loss_sigma = 0.0 total1 = 0.0 timer = time.time() for i, data in enumerate(tqdm(train_loader, 0)): if len(data[0])==1: continue torch.cuda.synchronize() #print(i) # 1 load imputs and target points_xyzc,points_1xyz,points2_xyz,points3_xyz,label,vid_name = data #if i == 1: #print(vid_name) points_xyzc,points_1xyz,points2_xyz,points3_xyz,label = points_xyzc.cuda(),points_1xyz.cuda(),points2_xyz.cuda(),points3_xyz.cuda(),label.cuda() #print(points_xyz.shape) #print(label,vid_name) # points: B*2048*4; target: B*1 opt.ball_radius = opt.ball_radius + random.uniform(-0.02,0.02) xt, yt = group_points_pro(points_xyzc, opt) xs1, ys1 = group_points(points_1xyz, opt) xs2, ys2 = group_points(points2_xyz, opt) xs3, ys3 = group_points(points3_xyz, opt) #print('123',inputs_level1_r[1,:,55]) #print(inputs_level1_r.shape,'123',inputs_level1_r[1,:,88,55]) # 2 compute outputs: prediction = netR(xt, xs1, xs2, xs3, yt, ys1, ys2, ys3) #print(pridiction) loss = criterion(prediction,label) optimizer.zero_grad() # compute gradient and do SGD step loss.backward() optimizer.step() torch.cuda.synchronize() # update training error loss_sigma += loss.item() #print(prediction.data.shape) #_, predicted60 = torch.max(prediction.data[:,0:60], 1) _, predicted = torch.max(prediction.data, 1) #print(predicted,'----',label) #print(predicted.shape,predicted60) #print(predicted,predicted60) #print(predicted==label) #print(label,'label') acc += (predicted==label).cpu().sum().numpy() total1 += label.size(0) acc_avg = acc/total1 loss_avg = loss_sigma/total1 print('======>>>>> Online epoch: #%d, lr=%f,Acc=%f,avg_loss=%f <<<<<======' %(epoch, scheduler.get_lr()[0],acc_avg,loss_avg)) #print("Epoch: " + str(epoch) + " Iter: " + str(i) + " Acc: " + ("%.2f" % acc_avg) +" Classification Loss: " + str(loss_avg)) if epoch>-1: # evaluate mode torch.cuda.synchronize() netR.eval() conf_mat = np.zeros([opt.Num_Class, opt.Num_Class]) acc = 0.0 loss_sigma = 0.0 for i, data in enumerate(tqdm(val_loader)): #print(i) if i >-1: torch.cuda.synchronize() points_xyzc,points_1xyz,points2_xyz,points3_xyz,label,vid_name = data #if i == 1: #print(vid_name) points_xyzc,points_1xyz,points2_xyz,points3_xyz,label = points_xyzc.cuda(),points_1xyz.cuda(),points2_xyz.cuda(),points3_xyz.cuda(),label.cuda() #print(points_xyz.shape) #print(label,vid_name) # points: B*2048*4; target: B*1 opt.ball_radius = opt.ball_radius + random.uniform(-0.02,0.02) xt, yt = group_points_pro(points_xyzc, opt) xs1, ys1 = group_points(points_1xyz, opt) xs2, ys2 = group_points(points2_xyz, opt) xs3, ys3 = group_points(points3_xyz, opt) #print('123',inputs_level1_r[1,:,55]) #print(inputs_level1_r.shape,'123',inputs_level1_r[1,:,88,55]) # 2 compute outputs: prediction = netR(xt, xs1, xs2, xs3, yt, ys1, ys2, ys3) #print(pridiction) loss = criterion(prediction,label) _, predicted = torch.max(prediction.data, 1) #print(prediction.data) loss_sigma += loss.item() for j in range(len(label)): cate_i = label[j].cpu().numpy() #print(cate_i) pre_i = predicted[j].cpu().numpy() conf_mat[cate_i, pre_i] += 1.0 print('UCLA:{:.2%} ===Average loss:{:.6%}'.format(conf_mat.trace() / conf_mat.sum(),loss_sigma/(i+1)/16)) logging.info('{} --epoch{} UCLA:{:.2%} ===Average loss:{:.6%}'.format('Valid',epoch,conf_mat.trace() / conf_mat.sum(),loss_sigma/(i+1)/16)) torch.save(netR.module.state_dict(), '%s/pointnet_para_%d.pth' % (opt.save_root_dir, epoch))
def main(args=None): parser = argparse.ArgumentParser(description="Training") parser.add_argument('--batchSize', type=int, default=64, help='input batch size') parser.add_argument('--nepoch', type=int, default=50, help='number of epochs to train for') parser.add_argument('--INPUT_FEATURE_NUM', type=int, default=8, help='number of input point features') parser.add_argument('--temperal_num', type=int, default=3, help='number of input point features') parser.add_argument( '--pooling', type=str, default='concatenation', help= 'how to aggregate temporal split features: vlad | concatenation | bilinear' ) parser.add_argument( '--dataset', type=str, default='ntu120', help='how to aggregate temporal split features: ntu120 | ntu60') parser.add_argument('--weight_decay', type=float, default=0.0008, help='weight decay (SGD only)') parser.add_argument('--learning_rate', type=float, default=0.001, help='learning rate at t=0') parser.add_argument('--momentum', type=float, default=0.9, help='momentum (SGD only)') parser.add_argument('--workers', type=int, default=0, help='number of data loading workers') parser.add_argument( '--root_path', type=str, default= '/data/data3/wangyancheng/pointcloudData/NTU_voxelz40_feature_2048', help='preprocess folder') parser.add_argument('--depth_path', type=str, default='/data/data3/wangyancheng/ntu120dataset/', help='raw_depth_png') parser.add_argument( '--save_root_dir', type=str, default='results_ntu120/NTU60_v40_cv_notransform_MultiStream', help='output folder') parser.add_argument('--model', type=str, default='', help='model name for training resume') parser.add_argument('--optimizer', type=str, default='', help='optimizer name for training resume') parser.add_argument('--ngpu', type=int, default=1, help='# GPUs') parser.add_argument( '--main_gpu', type=int, default=0, help='main GPU id') # CUDA_VISIBLE_DEVICES=0 python train.py parser.add_argument('--learning_rate_decay', type=float, default=1e-7, help='learning rate decay') parser.add_argument('--size', type=str, default='full', help='how many samples do we load: small | full') parser.add_argument('--SAMPLE_NUM', type=int, default=2048, help='number of sample points') parser.add_argument('--Num_Class', type=int, default=120, help='number of outputs') parser.add_argument('--knn_K', type=int, default=64, help='K for knn search') parser.add_argument('--sample_num_level1', type=int, default=512, help='number of first layer groups') parser.add_argument('--sample_num_level2', type=int, default=128, help='number of second layer groups') parser.add_argument('--ball_radius', type=float, default=0.16, help='square of radius for ball query in level 1' ) #0.025 -> 0.05 for detph parser.add_argument('--ball_radius2', type=float, default=0.25, help='square of radius for ball query in level 2' ) # 0.08 -> 0.01 for depth opt = parser.parse_args() print(opt) torch.cuda.set_device(opt.main_gpu) opt.manualSeed = 1 random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) try: os.makedirs(opt.save_root_dir) except OSError: pass os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3' torch.backends.cudnn.benchmark = True #torch.backends.cudnn.deterministic = True torch.cuda.empty_cache() data_train = NTU_RGBD(root_path=opt.root_path, opt=opt, DATA_CROSS_VIEW=True, full_train=True, validation=False, test=False, Transform=False) train_loader = DataLoader(dataset=data_train, batch_size=opt.batchSize, shuffle=True, drop_last=True, num_workers=8) data_val = NTU_RGBD(root_path=opt.root_path, opt=opt, DATA_CROSS_VIEW=True, full_train=False, validation=False, test=True, Transform=False) val_loader = DataLoader(dataset=data_val, batch_size=24, num_workers=8) netR = PointNet_Plus(opt) netR = torch.nn.DataParallel(netR).cuda() netR.cuda() print(netR) criterion = torch.nn.CrossEntropyLoss().cuda() optimizer = torch.optim.Adam(netR.parameters(), lr=opt.learning_rate, betas=(0.5, 0.999), eps=1e-06) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=8, gamma=0.5) for epoch in range(opt.nepoch): scheduler.step(epoch) # switch to train mode torch.cuda.synchronize() netR.train() acc = 0.0 loss_sigma = 0.0 total1 = 0.0 timer = time.time() for i, data in enumerate(tqdm(train_loader, 0)): if len(data[0]) == 1: continue torch.cuda.synchronize() # 1 load imputs and target ## 3DV points and 3 temporal segment appearance points ## points_xyzc: B*2048*8;points_1xyz:B*2048*3 target: B*1 points_xyzc, points_1xyz, points2_xyz, points3_xyz, label, v_name = data points_xyzc, points_1xyz, points2_xyz, points3_xyz, label = points_xyzc.cuda( ), points_1xyz.cuda(), points2_xyz.cuda(), points3_xyz.cuda( ), label.cuda() ## group for 3DV points opt.ball_radius = opt.ball_radius + random.uniform(-0.02, 0.02) xt, yt = group_points_3DV(points_xyzc, opt) ## group for appearance points (3 seg) xs1, ys1 = group_points(points_1xyz, opt) xs2, ys2 = group_points(points2_xyz, opt) xs3, ys3 = group_points(points3_xyz, opt) prediction = netR(xt, xs1, xs2, xs3, yt, ys1, ys2, ys3) loss = criterion(prediction, label) optimizer.zero_grad() loss.backward() optimizer.step() torch.cuda.synchronize() # update training error loss_sigma += loss.item() #_, predicted60 = torch.max(prediction.data[:,0:60], 1) _, predicted = torch.max(prediction.data, 1) acc += (predicted == label).cpu().sum().numpy() total1 += label.size(0) acc_avg = acc / total1 loss_avg = loss_sigma / total1 print( '======>>>>> Online epoch: #%d, lr=%f,Acc=%f,avg_loss=%f <<<<<======' % (epoch, scheduler.get_lr()[0], acc_avg, loss_avg)) #print("Epoch: " + str(epoch) + " Iter: " + str(i) + " Acc: " + ("%.2f" % acc_avg) +" Classification Loss: " + str(loss_avg)) if epoch > 5: # evaluate mode torch.cuda.synchronize() netR.eval() conf_mat = np.zeros([opt.Num_Class, opt.Num_Class]) conf_mat60 = np.zeros([60, 60]) acc = 0.0 loss_sigma = 0.0 for i, data in enumerate(tqdm(val_loader)): torch.cuda.synchronize() points_xyzc, points_1xyz, points2_xyz, points3_xyz, label, v_name = data points_xyzc, points_1xyz, points2_xyz, points3_xyz, label = points_xyzc.cuda( ), points_1xyz.cuda(), points2_xyz.cuda(), points3_xyz.cuda( ), label.cuda() opt.ball_radius = opt.ball_radius + random.uniform(-0.02, 0.02) xt, yt = group_points_3DV(points_xyzc, opt) xs1, ys1 = group_points(points_1xyz, opt) xs2, ys2 = group_points(points2_xyz, opt) xs3, ys3 = group_points(points3_xyz, opt) prediction = netR(xt, xs1, xs2, xs3, yt, ys1, ys2, ys3) loss = criterion(prediction, label) _, predicted60 = torch.max(prediction.data[:, 0:60], 1) _, predicted = torch.max(prediction.data, 1) #print(prediction.data) loss_sigma += loss.item() for j in range(len(label)): cate_i = label[j].cpu().numpy() pre_i = predicted[j].cpu().numpy() conf_mat[cate_i, pre_i] += 1.0 if cate_i < 60: pre_i60 = predicted60[j].cpu().numpy() conf_mat60[cate_i, pre_i60] += 1.0 print('NTU120:{:.2%} NTU60:{:.2%}===Average loss:{:.6%}'.format( conf_mat.trace() / conf_mat.sum(), conf_mat60.trace() / conf_mat60.sum(), loss_sigma / (i + 1) / 2)) #logging.info('{} --epoch{} set Accuracy:{:.2%}===Average loss:{}'.format('Valid', epoch, conf_mat.trace() / conf_mat.sum(), loss_sigma/(i+1))) torch.save(netR.module.state_dict(), '%s/pointnet_para_%d.pth' % (opt.save_root_dir, epoch))
def update(self): try: self.height, self.width, channels = self.img.shape except: return #update the labels selection tempselect = False for l in self.labels: l.update() #deselecting if self.world.mouse_left_down: if (self.x < self.world.mouse_x < self.x + self.width and self.y < self.world.mouse_y < self.y + self.height): t = l.checkselect() if t: tempselect = True if self.world.mouse_left_down: if (self.x < self.world.mouse_x < self.x + self.width and self.y < self.world.mouse_y < self.y + self.height): if not tempselect: self.updatelabelselect(None) #start single select if self.world.mouse_left_down: if self.selectsinglebox: if (self.x < self.world.mouse_x < self.x + self.width and self.y < self.world.mouse_y < self.y + self.height): self.selectbox[0] = self.world.mouse_x self.selectbox[1] = self.world.mouse_y self.selecting = True self.selected = False #start multi select if self.world.mouse_left_down: if self.selectmultibox: if (self.x < self.world.mouse_x < self.x + self.width and self.y < self.world.mouse_y < self.y + self.height): self.selectbox[0] = self.world.mouse_x self.selectbox[1] = self.world.mouse_y self.selecting = True self.selected = False self.lines = [] self.intersections = [] #self.labels=[] self.tempautolabels = [] if self.selecting: self.selectbox[2] = clamp(self.world.mouse_x - self.selectbox[0], self.x - self.selectbox[0], self.x + self.width - self.selectbox[0]) self.selectbox[3] = clamp(self.world.mouse_y - self.selectbox[1], self.y - self.selectbox[1], self.y + self.height - self.selectbox[1]) #single if self.selectsinglebox: if self.world.mouse_left_up: self.selecting = False self.selectmultibox = False if abs(self.selectbox[2]) > 0 and abs( self.selectbox[3]) > 0: self.selected = True #create the label #if not self.controller.actionbar.classes==None: if not self.controller.actionbar.selected == None: labeltext = self.controller.actionbar.classes[ self.controller.actionbar.selected] labelcolor = hsv_to_rgb( self.controller.actionbar.colors[ self.controller.actionbar.selected]. slideValue / 360, 1, 1) else: labeltext = "None" labelcolor = (0, 0, 0) l = label(self.world, self, self.selectbox[0] - self.x, self.selectbox[1] - self.y, self.selectbox[2], self.selectbox[3], labeltext, labelcolor) self.labels.append(l) self.selectsinglebox = False #select the label that was just created self.updatelabelselect(l) l.selected = True else: self.selected = False return #multi if self.selectmultibox: if self.world.mouse_left_up: self.selecting = False self.selectmultibox = False if abs(self.selectbox[2]) > 0 and abs( self.selectbox[3]) > 0: self.selected = True else: self.selected = False return #create the template if self.selectbox[2] > 0: x1 = self.selectbox[0] - self.x x2 = self.selectbox[0] + self.selectbox[2] - self.x else: x1 = self.selectbox[0] + self.selectbox[2] - self.x x2 = self.selectbox[0] - self.x if self.selectbox[3] > 0: y1 = self.selectbox[1] - self.y y2 = self.selectbox[1] + self.selectbox[3] - self.y else: y1 = self.selectbox[1] + self.selectbox[3] - self.y y2 = self.selectbox[1] - self.y self.template = self.img[y1:y2, x1:x2] #run template matching, get minimum val gray = cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY) template = cv2.cvtColor(self.template, cv2.COLOR_BGR2GRAY) res = cv2.matchTemplate( gray, template, cv2.TM_CCOEFF_NORMED) #TM_SQDIFF_NORMED min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) # create threshold from min val, find where sqdiff is less than thresh min_thresh = .9 # (min_val + 1e-6) * 1.5 match_locations = np.where(res >= min_thresh) match_locations = (np.array(match_locations).T).tolist() match_locations = group_points(match_locations, 10) #get the defaults from the actionbar try: labeltext = self.controller.actionbar.classes[ self.controller.actionbar.defaultmatch] labelcolor = hsv_to_rgb( self.controller.actionbar.colors[ self.controller.actionbar.defaultmatch]. slideValue / 360, 1, 1) except: labeltext = "NONE" labelcolor = (0, 0, 0) for m in match_locations: l = label(self.world, self, m[1], m[0], self.selectbox[2], self.selectbox[3], labeltext, (0, 255, 0)) #self.labels.append(l) self.tempautolabels.append(l) #print(self.match_locations) self.predict_missing_boxes(labeltext)
def main(args=None): parser = argparse.ArgumentParser(description = "Training") parser.add_argument('--batchSize', type=int, default=36, help='input batch size') parser.add_argument('--nepoch', type=int, default=80, help='number of epochs to train for') parser.add_argument('--INPUT_FEATURE_NUM', type=int, default = 8, help='number of input point features') parser.add_argument('--temperal_num', type=int, default = 3, help='number of input point features') parser.add_argument('--pooling', type=str, default='concatenation', help='how to aggregate temporal split features: vlad | concatenation | bilinear') parser.add_argument('--dataset', type=str, default='ntu60', help='how to aggregate temporal split features: ntu120 | ntu60') parser.add_argument('--weight_decay', type=float, default=0.0008, help='weight decay (SGD only)') parser.add_argument('--learning_rate', type=float, default=0.001, help='learning rate at t=0') parser.add_argument('--momentum', type=float, default=0.9, help='momentum (SGD only)') parser.add_argument('--workers', type=int, default=0, help='number of data loading workers') parser.add_argument('--root_path', type=str, default='/data/data3/wangyancheng/pointcloudData/NTU_voxelz40_feature_2048', help='preprocess folder') parser.add_argument('--depth_path', type=str, default='/data/data3/wangyancheng/ntu120dataset/', help='raw_depth_png') parser.add_argument('--save_root_dir', type=str, default='results_ntu120/NTU60_v40_cv_MultiStream', help='output folder') parser.add_argument('--model', type=str, default = '', help='model name for training resume') parser.add_argument('--optimizer', type=str, default = '', help='optimizer name for training resume') parser.add_argument('--ngpu', type=int, default=1, help='# GPUs') parser.add_argument('--main_gpu', type=int, default=0, help='main GPU id') # CUDA_VISIBLE_DEVICES=0 python train.py parser.add_argument('--learning_rate_decay', type=float, default=1e-7, help='learning rate decay') parser.add_argument('--size', type=str, default='full', help='how many samples do we load: small | full') parser.add_argument('--SAMPLE_NUM', type=int, default = 2048, help='number of sample points') parser.add_argument('--Num_Class', type=int, default = 120, help='number of outputs') parser.add_argument('--knn_K', type=int, default = 64, help='K for knn search') parser.add_argument('--sample_num_level1', type=int, default = 512, help='number of first layer groups') parser.add_argument('--sample_num_level2', type=int, default = 128, help='number of second layer groups') parser.add_argument('--ball_radius', type=float, default=0.16, help='square of radius for ball query in level 1')#0.025 -> 0.05 for detph parser.add_argument('--ball_radius2', type=float, default=0.25, help='square of radius for ball query in level 2')# 0.08 -> 0.01 for depth opt = parser.parse_args() print (opt) logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%Y/%m/%d %H:%M:%S', filename=os.path.join(opt.save_root_dir, 'print.log'), level=logging.INFO) torch.cuda.set_device(opt.main_gpu) opt.manualSeed = 1 random.seed(opt.manualSeed) torch.manual_seed(opt.manualSeed) try: os.makedirs(opt.save_root_dir) except OSError: pass os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3' torch.backends.cudnn.benchmark = True #torch.backends.cudnn.deterministic = True torch.cuda.empty_cache() data_val = NTU_RGBD(root_path = opt.root_path, opt=opt, DATA_CROSS_VIEW = True, full_train = False, validation = False, test = True, Transform = False ) val_loader = DataLoader(dataset = data_val, batch_size = 18,num_workers = 8) #net = netR = PointNet_Plus(opt) netR.load_state_dict(torch.load("/results_ntu120/NTU60_v40_cv_MultiStream/pointnet_para_45.pth")) netR = torch.nn.DataParallel(netR).cuda() netR.cuda() print(netR) # evaluate mode torch.cuda.synchronize() netR.eval() conf_mat = np.zeros([opt.Num_Class, opt.Num_Class]) conf_mat60 = np.zeros([60, 60]) acc = 0.0 loss_sigma = 0.0 for i, data in enumerate(tqdm(val_loader)): #print(i) torch.cuda.synchronize() group_time_start = time.time() points_xyzc,points_1xyz,points2_xyz,points3_xyz,label,vid_name = data points_xyzc,points_1xyz,points2_xyz,points3_xyz,label = points_xyzc.cuda(),points_1xyz.cuda(),points2_xyz.cuda(),points3_xyz.cuda(),label.cuda() #print(points.shape,'===') #print(label,'label') # points: B*2048*4; target: B*1 opt.ball_radius = opt.ball_radius + random.uniform(-0.02,0.02) xt, yt = group_points_pro(points_xyzc, opt) xs1, ys1 = group_points(points_1xyz, opt) xs2, ys2 = group_points(points2_xyz, opt) xs3, ys3 = group_points(points3_xyz, opt) forward_time_start = time.time() #print(inputs_level1.shape,inputs_level1_center.shape) prediction = netR(xt, xs1, xs2, xs3, yt, ys1, ys2, ys3) forward_time_end = time.time() print('forward time:',forward_time_end-forward_time_start) _, predicted60 = torch.max(prediction.data[:,0:60], 1) _, predicted = torch.max(prediction.data, 1) #print(prediction.data) for j in range(len(label)): cate_i = label[j].cpu().numpy() pre_i = predicted[j].cpu().numpy() if pre_i != cate_i: logging.info('Video Name:{} -- correct label {} predicted to {}'.format(vid_name[j],cate_i,pre_i)) conf_mat[cate_i, pre_i] += 1.0 if cate_i<60: pre_i60 = predicted60[j].cpu().numpy() conf_mat60[cate_i, pre_i60] += 1.0 print('NTU120:{:.2%} NTU60:{:.2%}===Average loss:{:.6%}'.format(conf_mat.trace() / conf_mat.sum(),conf_mat60.trace() / conf_mat60.sum(),loss_sigma/(i+1)/2)) logging.info('{} --epoch{} set Accuracy:{:.2%}===Average loss:{}'.format('Valid', epoch, conf_mat.trace() / conf_mat.sum(), loss_sigma/(i+1)))
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D import ztorch_simulation import utils plt_color_codes = 'bgrcmykw' sim200 = ztorch_simulation.Simulation(std=2.0, steps=1, on_the_fly=True) steps, centres, aff_groups, points, granularity = sim200.run_ekm() vnf_groups = utils.group_points(points, aff_groups) plot_ekm_results = True if plot_ekm_results: fig = plt.figure() ax = fig.gca(projection='3d') avail_colors = set(plt_color_codes) for gid in vnf_groups: group = vnf_groups[gid] if len(avail_colors) > 0: color = avail_colors.pop() ax.scatter(*group.T, c=color, alpha=0.3) ax.set_xlabel('CPU ($\mu$) [%]') ax.set_ylabel('Memory ($m$) [%]') ax.set_zlabel('Network ($\eta$) [%]')