def main(): data_path = '/data/dataset/svhn' train_data = dataset.joint_data_loader(data_path, data_path, PP) test_data = dataset.joint_data_loader(data_path, data_path, is_training=False) train_loader = DataLoader(train_data, batch_size=BATCH_SIZE, num_workers=2, shuffle=True, drop_last=True) test_loader = DataLoader(test_data, batch_size=4, num_workers=2, shuffle=False) net = vgg.LeNet(14) net.apply(weights_init) cudnn.benchmark = True net.train().cuda() criterion = nn.CrossEntropyLoss() trainable_list = filter(lambda p: p.requires_grad, net.parameters()) other_base_list = filter(lambda p: p[0].split('.')[-1] != 'bases1', net.named_parameters()) other_base_list = [ x[1] for x in other_base_list if x[1].requires_grad == True ] named_base_list = filter(lambda p: p[0].split('.')[-1] != 'bases0', net.named_parameters()) base_list = [x[1] for x in named_base_list if x[1].requires_grad == True] print('Totolly %d bases for domain1' % (len(base_list))) main_list = other_base_list # optimizer = torch.optim.SGD(net.parameters(), FLAGS.learning_rate, 0.9, weight_decay=0.0001, nesterov=True) if OPTIMIZER == 'momentum': optimizer = torch.optim.SGD(net.parameters(), BASE_LEARNING_RATE / 1, 0.9, weight_decay=0.0001, nesterov=True) elif OPTIMIZER == 'adam': optimizer = torch.optim.Adam(net.parameters(), BASE_LEARNING_RATE, weight_decay=0.0001) ###__0.0001->0.001 elif OPTIMIZER == 'rmsp': optimizer = torch.optim.RMSprop(net.parameters(), BASE_LEARNING_RATE, weight_decay=0.0001) count = 1 epoch = 0 cudnn.benchmark = True MOVING_SCALE = 100 loss_ma0 = MovingAverage(MOVING_SCALE) loss_ma1 = MovingAverage(MOVING_SCALE) loss_dis_ma = MovingAverage(MOVING_SCALE) loss_style_ma = MovingAverage(MOVING_SCALE) loss_main_ma = MovingAverage(MOVING_SCALE) loss_sim_ma = MovingAverage(MOVING_SCALE) #loss_l1 = MovingAverage(100) acc_ma_0 = MovingAverage(MOVING_SCALE) acc_ma_1 = MovingAverage(MOVING_SCALE) test_loss = AverageMeter() test_acc = AverageMeter() while True: if epoch >= MAX_EPOCH: break epoch += 1 log_string('********Epoch %d********' % (epoch)) for i, data in enumerate(train_loader): img0, img1, gt0, gt1 = data # img1, img0, gt1, gt0 = data # pdb.set_trace() count += 1 imgs_in_0 = Variable(img0).float().cuda() gt_in_0 = Variable(gt0).long().cuda() imgs_in_1 = Variable(img1).float().cuda() gt_in_1 = Variable(gt1).long().cuda() pred = net(torch.cat([imgs_in_0, imgs_in_1], 0)) # pdb.set_trace() pred0 = pred[:BATCH_SIZE] pred1 = pred[BATCH_SIZE:] f0 = net.feature[:BATCH_SIZE] f1 = net.feature[BATCH_SIZE:] loss0 = criterion(pred0, gt_in_0) loss1 = criterion(pred1, gt_in_1) loss_all = loss0 + loss1 acc_this_0 = accuracy(pred0, gt_in_0) acc_ma_0.update(acc_this_0[0].item()) acc_this_1 = accuracy(pred1, gt_in_1) acc_ma_1.update(acc_this_1[0].item()) optimizer.zero_grad() loss_all.backward() optimizer.step() optimizer.zero_grad() loss_ma0.update(loss0.item()) loss_ma1.update(loss1.item()) if count % FLAGS.print_inter == 0: log_string('[Current iter %d, accuracy0 is %3.2f, accuracy1 is %3.2f, \ loss0 is %2.6f, loss1 is %2.6f, lr: %f]' %(count, acc_ma_0.avg, acc_ma_1.avg, \ loss_ma0.avg, loss_ma1.avg, \ optimizer.param_groups[0]['lr'])) if count % 500 == 0: validation(test_loader, net, criterion, count, epoch, test_loss, test_acc) if count % 1000 == 0: torch.save(net.state_dict(), './' + LOG_DIR + '/' + 'model.pth') if count % DECAY_STEP == 0 and optimizer.param_groups[0]['lr'] >= ( BASE_LEARNING_RATE / 10.0): optimizer.param_groups[0][ 'lr'] = optimizer.param_groups[0]['lr'] / 10.0 optimizer_base1.param_groups[0][ 'lr'] = optimizer_base1.param_groups[0]['lr'] / 10.0 optimizer_dis.param_groups[0][ 'lr'] = optimizer_dis.param_groups[0]['lr'] / 10.0 log_string('Training reaches maximum epoch.')
def main(): USE_PZH = True # initialize interface001, interface002, pzhdata = ship_initialize(True, True, True) t = PeriodTimer(0.2) diff_x_average_gps = MovingAverage(100) diff_y_average_gps = MovingAverage(100) diff_x_average_lidar = MovingAverage(100) diff_y_average_lidar = MovingAverage(100) # t.start() cnt = 0 end = 200 try: while True: with t: self_state = interface001.receive('gps.posx', 'gps.posy', 'ahrs.yaw', 'ahrs.yaw_speed', 'gps.hspeed', 'gps.stdx', 'gps.stdy', 'gps.track') target_state = interface002.receive('gps.posx', 'gps.posy', 'ahrs.yaw', 'ahrs.yaw_speed', 'gps.hspeed', 'gps.stdx', 'gps.stdy', 'gps.track') assert pzhdata is not None lidar_data = pzhdata.receive() if lidar_data["terminated"]: print( "Peng Zhenghao's program is terminated. For safety we close this program." ) break target = lidar_data["target"] if not target: print("No Target Specified!") continue else: cnt += 1 # print("Current CNT") goal = lidar_data[target] # goal = [x, y] diff_x = target_state[POS_X] - self_state[POS_X] diff_y = target_state[POS_Y] - self_state[POS_Y] diff_x_average_gps.update(diff_x) diff_y_average_gps.update(diff_y) diff_x_average_lidar.update(goal[0]) diff_y_average_lidar.update(goal[1]) phi2 = -atan2(diff_y_average_gps.avg, diff_x_average_gps.avg) - pi / 2 phi1 = atan2(diff_y_average_lidar.avg, diff_x_average_lidar.avg) out = phi1 + phi2 - pi / 2 # offset = atan2(diff_y_average_lidar.avg, diff_x_average_lidar.avg) - \ # atan2(diff_y_average_gps.avg, diff_x_average_gps.avg) print("[CNT {}] Current GPS ({}, {}), LiDAR ({}, {}). \ ph1{}, ph2 {}, out {} ({} deg).".format( cnt, diff_x_average_gps.avg, diff_y_average_gps.avg, diff_x_average_lidar.avg, diff_y_average_lidar.avg, phi1, phi2, out, out * 180 / pi)) if cnt >= end: break finally: import pickle import time def get_formatted_time(timestamp=None): if not timestamp: return time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime()) else: return time.strftime('%Y-%m-%d_%H-%M-%S', time.localtime(timestamp)) if diff_y_average_lidar.avg is not None: phi2 = -atan2(diff_y_average_gps.avg, diff_x_average_gps.avg) - pi / 2 phi1 = atan2(diff_y_average_lidar.avg, diff_x_average_lidar.avg) out = phi1 + phi2 - pi / 2 out = atan2(diff_y_average_lidar.avg, diff_x_average_lidar.avg) - \ atan2(diff_y_average_gps.avg, diff_x_average_gps.avg) pickle.dump( { "offset": out, "timestamp": time.time(), "time": get_formatted_time() }, open("offset.pkl", "wb")) print("Data have saved to offset.pkl") else: print("Data is not received.") time.sleep(0.5) interface001.dev.close() interface002.dev.close() pzhdata.dev.close() print('dev closed')
def main(): train_data = dataset.AFLW('/data/dataset/face/aflw/AFLWinfo_release.mat', '/data/dataset/face/aflw/data/flickr/', 256, is_training=True) test_data = dataset.AFLW('/data/dataset/face/aflw/AFLWinfo_release.mat', '/data/dataset/face/aflw/data/flickr/', 256, is_training=False) train_loader = DataLoader(train_data, batch_size=BATCH_SIZE, num_workers=4, shuffle=True, drop_last=True) test_loader = DataLoader(test_data, batch_size=1, num_workers=4, shuffle=False) # net = model.DenseNet() # net = model.DenseNet_nz() # net = model1.vgg_19() net = resnet50(pretrained=True) net.apply(weight_init) net.train().cuda() loss_func = nn.CrossEntropyLoss().cuda() criterion = l1_loss(False).cuda() if OPTIMIZER == 'momentum': optimizer = torch.optim.SGD(net.parameters(), BASE_LEARNING_RATE, 0.9, weight_decay=0.0001, nesterov=True) elif OPTIMIZER == 'adam': optimizer = torch.optim.Adam(net.parameters(), BASE_LEARNING_RATE, weight_decay=0.0001) ###__0.0001->0.001 elif OPTIMIZER == 'rmsp': optimizer = torch.optim.RMSprop(net.parameters(), BASE_LEARNING_RATE, weight_decay=0.0001) # optimizer = torch.optim.SGD(net.parameters(), learning_rate, 0.9, weight_decay=0.0001, nesterov=True) count = 1 epoch = 0 loss_ma = MovingAverage(100) test_loss = AverageMeter() while True: epoch += 1 log_string('********Epoch %d********' % (epoch)) for i, data in enumerate(train_loader): imgs, gt = data count += 1 imgs_in = Variable(imgs).float().cuda() gt_in = Variable(gt).float().cuda() pred = net(imgs_in) loss = criterion(pred, gt_in) # loss = loss0 + loss1 optimizer.zero_grad() loss.backward() optimizer.step() loss_ma.update(loss.data[0]) if count % 100 == 0: log_string( '[Current iter %d, l1 loss is %2.6f, lr: %f]' % (count, loss_ma.avg, optimizer.param_groups[0]['lr'])) out_im = imgs[0].numpy() out_gt = gt[0].numpy() out_pred = pred[0].cpu().data.numpy().squeeze() dataset.draw_im(out_im, out_gt, out_pred, count, 0, LOG_DIR, is_training=True) if count % 1000 == 0: validation(test_loader, net, criterion, count, epoch, test_loss) if count % 1000 == 0: torch.save(net, './' + LOG_DIR + '/' + 'model.pth') if count % 15000 == 0 and optimizer.param_groups[0]['lr'] >= ( BASE_LEARNING_RATE / 100.0): optimizer.param_groups[0][ 'lr'] = optimizer.param_groups[0]['lr'] / 10.0