def __init__(self):
self.kf = KalmanFilter()
self.min_ap_dist = 0.64
self.tracks = []
self.remove_tracks = []
self.track_id = 0
self.vis_tool = Visualizer("MOTDN")
def main():
begin = time.time()
viser = Visualizer()
args = parse_arguments()
hidden_size = 256
embed_size = 128
assert torch.cuda.is_available()
print("[!] preparing dataset...")
train_iter, test_iter, val_iter, corpus = load_dataset(args.batch_size)
zh_size, en_size = corpus.zh_size, corpus.en_size
print("[!] Instantiating models...")
encoder = Encoder(en_size,
embed_size,
hidden_size,
n_layers=2,
dropout=0.5)
decoder = Decoder(embed_size,
hidden_size,
zh_size,
n_layers=1,
dropout=0.5)
seq2seq = Seq2Seq(encoder, decoder).cuda()
optimizer = optim.Adam(seq2seq.parameters(), lr=args.lr)
print("[!] Begin to train")
for e in range(1, args.epochs + 1):
train(e, seq2seq, optimizer, train_iter, zh_size, args.grad_clip,
corpus, viser, begin)
# val_loss = evaluate(seq2seq, val_iter, zh_size, corpus)
# print("[Epoch:%d] val_loss:%5.3f | val_pp:%5.2fS"
# % (e, val_loss, math.exp(val_loss)))
# Save the model if the validation loss is the best we've seen so far.
# if not best_val_loss or val_loss < best_val_loss:
if True:
print("[!] best model occur, saving model...")
# If find the new best model, try to plot text
if not os.path.isdir(".save"):
os.makedirs(".save")
torch.save(seq2seq.state_dict(), '.save/seq2seq_%d.pt' % (e))
# plot text from the test dataset
# only plot 1 sentences
test_batch = random.choice(train_iter)
src = test_batch.get_src()[:, 0].unsqueeze(0).cuda()
trg = test_batch.get_target()[:, 0].cuda()
pre = seq2seq.eval_forward(src, 100, corpus.zh_stoi['<sos>'])
src_sent = ' '.join([corpus.en_itos[int(word)] for word in src[0]])
trg_sent = ' '.join([corpus.zh_itos[int(word)] for word in trg])
pre_sent = ' '.join([corpus.zh_itos[int(word)] for word in pre])
viser.plot_text(e, src_sent, pre_sent, trg_sent)
# test_loss = evaluate(seq2seq, test_iter, zh_size, corpus)
# print("[TEST] Final loss:%5.2f" % test_loss)
print('[!] Training over')
def __init__(self, config):
# data
self.train_data = AnnPolygon(config, train=True)
self.val_data = AnnPolygon(config, train=False)
self.num_points = config.num_points
self.gt_num_points = config.gt_num_points
# model
self.model = Snake(state_dim=config.batch_size,
feature_dim=6,
conv_type='dgrid')
# Run on GPU/CPU
if torch.cuda.is_available():
self.device = torch.device(f"cuda:{config.multi_gpu[0]}")
else:
self.device = torch.device(f"cpu")
# check if load from existing model
if config.reload_model_path:
self.model.load(config.reload_model_path)
else:
self.model.cuda()
self.train_dataloader = DataLoader(self.train_data,
config.batch_size,
shuffle=True,
num_workers=config.num_workers,
drop_last=True)
self.val_dataloader = DataLoader(self.val_data,
config.batch_size,
shuffle=True,
num_workers=config.num_workers,
drop_last=True)
# optimizer
self.criterion = dist_chamfer_2D.chamfer_2DDist()
if config.optimizer == "adam":
self.lr = config.learning_rate
self.optimizer = Adam(self.model.parameters(), lr=self.lr)
elif config.optimizer == "sgd":
self.lr = config.learning_rate / 10
self.optimizer = SGD(self.model.parameters(), lr=self.lr)
self.train_loss = meter.AverageValueMeter()
self.val_loss = meter.AverageValueMeter()
self.epochs = config.epochs
self.vis = Visualizer(config)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('filename',
type=str) # defaultIS.h5/snapshots/iter0000480
parser.add_argument('--vid', type=str, default='/tmp/madrl.mp4')
parser.add_argument('--deterministic', action='store_true', default=False)
parser.add_argument('--heuristic', action='store_true', default=False)
parser.add_argument('--evaluate', action='store_true', default=False)
parser.add_argument('--n_trajs', type=int, default=20)
parser.add_argument('--n_steps', type=int, default=500)
parser.add_argument('--same_con_pol', action='store_true')
args = parser.parse_args()
fh = FileHandler(args.filename)
env_map = TwoDMaps.rectangle_map(
*map(int, fh.train_args['map_size'].split(',')))
map_pool = [env_map]
# map_pool = np.load(
# os.path.join('/scratch/megorov/deeprl/MADRL/runners/maps/', os.path.basename(fh.train_args[
# 'map_file'])))
env = PursuitEvade(map_pool,
n_evaders=fh.train_args['n_evaders'],
n_pursuers=fh.train_args['n_pursuers'],
obs_range=fh.train_args['obs_range'],
n_catch=fh.train_args['n_catch'],
urgency_reward=fh.train_args['urgency'],
surround=bool(fh.train_args['surround']),
sample_maps=bool(fh.train_args['sample_maps']),
flatten=bool(fh.train_args['flatten']),
reward_mech='global',
catchr=fh.train_args['catchr'],
term_pursuit=fh.train_args['term_pursuit'])
if fh.train_args['buffer_size'] > 1:
env = ObservationBuffer(env, fh.train_args['buffer_size'])
hpolicy = None
if args.heuristic:
from heuristics.pursuit import PursuitHeuristicPolicy
hpolicy = PursuitHeuristicPolicy(env.agents[0].observation_space,
env.agents[0].action_space)
if args.evaluate:
minion = Evaluator(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic,
'heuristic' if args.heuristic else fh.mode)
evr = minion(fh.filename,
file_key=fh.file_key,
same_con_pol=args.same_con_pol,
hpolicy=hpolicy)
from tabulate import tabulate
print(evr)
print(tabulate(evr, headers='keys'))
else:
minion = Visualizer(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic, fh.mode)
rew, info = minion(fh.filename, file_key=fh.file_key, vid=args.vid)
pprint.pprint(rew)
pprint.pprint(info)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('filename',
type=str) # defaultIS.h5/snapshots/iter0000480
parser.add_argument('--vid', type=str, default='/tmp/madrl.mp4')
parser.add_argument('--deterministic', action='store_true', default=False)
parser.add_argument('--heuristic', action='store_true', default=False)
parser.add_argument('--evaluate', action='store_true', default=False)
parser.add_argument('--n_trajs', type=int, default=10)
parser.add_argument('--n_steps', type=int, default=500)
parser.add_argument('--same_con_pol', action='store_true')
args = parser.parse_args()
fh = FileHandler(args.filename)
env = MAWaterWorld(
fh.train_args['n_pursuers'],
fh.train_args['n_evaders'],
fh.train_args['n_coop'],
fh.train_args['n_poison'],
n_sensors=fh.train_args['n_sensors'],
food_reward=fh.train_args['food_reward'],
poison_reward=fh.train_args['poison_reward'],
reward_mech='global',
encounter_reward=0, #fh.train_args['encounter_reward'],
addid=True,
)
if fh.train_args['buffer_size'] > 1:
env = ObservationBuffer(env, fh.train_args['buffer_size'])
hpolicy = None
if args.heuristic:
from heuristics.waterworld import WaterworldHeuristicPolicy
hpolicy = WaterworldHeuristicPolicy(env.agents[0].observation_space,
env.agents[0].action_space)
if args.evaluate:
minion = Evaluator(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic,
'heuristic' if args.heuristic else fh.mode)
evr = minion(fh.filename,
file_key=fh.file_key,
same_con_pol=args.same_con_pol,
hpolicy=hpolicy)
from tabulate import tabulate
print(tabulate(evr, headers='keys'))
else:
minion = Visualizer(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic,
'heuristic' if args.heuristic else fh.mode)
rew, info = minion(fh.filename,
file_key=fh.file_key,
vid=args.vid,
hpolicy=hpolicy)
pprint.pprint(rew)
pprint.pprint(info)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('filename',
type=str) # defaultIS.h5/snapshots/iter0000480
parser.add_argument('--vid', type=str, default='/tmp/madrl.mp4')
parser.add_argument('--deterministic', action='store_true', default=False)
parser.add_argument('--heuristic', action='store_true', default=False)
parser.add_argument('--evaluate', action='store_true', default=False)
parser.add_argument('--save_file', type=str, default=None)
parser.add_argument('--n_trajs', type=int, default=20)
parser.add_argument('--n_steps', type=int, default=500)
parser.add_argument('--same_con_pol', action='store_true')
args = parser.parse_args()
fh = FileHandler(args.filename)
env = MultiAnt(n_legs=fh.train_args['n_legs'],
ts=fh.train_args['ts'],
integrator=fh.train_args['integrator'],
out_file=fh.train_args['out_file'],
base_file=fh.train_args['base_file'],
reward_mech=fh.train_args['reward_mech'])
if fh.train_args['buffer_size'] > 1:
env = ObservationBuffer(env, fh.train_args['buffer_size'])
hpolicy = None
if args.evaluate:
minion = Evaluator(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic,
'heuristic' if args.heuristic else fh.mode)
evr = minion(fh.filename,
file_key=fh.file_key,
same_con_pol=args.same_con_pol,
hpolicy=hpolicy)
if args.save_file:
pickle.dump(evr, open(args.save_file, "wb"))
from tabulate import tabulate
#print(tabulate(evr, headers='keys'))
else:
minion = Visualizer(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic, fh.mode)
rew, info = minion(fh.filename, file_key=fh.file_key, vid=args.vid)
pprint.pprint(rew)
pprint.pprint(info)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('filename',
type=str) # defaultIS.h5/snapshots/iter0000480
parser.add_argument('--vid', type=str, default='/tmp/madrl.mp4')
parser.add_argument('--deterministic', action='store_true', default=False)
parser.add_argument('--heuristic', action='store_true', default=False)
parser.add_argument('--evaluate', action='store_true', default=False)
parser.add_argument('--n_trajs', type=int, default=20)
parser.add_argument('--n_steps', type=int, default=500)
parser.add_argument('--same_con_pol', action='store_true')
args = parser.parse_args()
fh = FileHandler(args.filename)
env = MultiWalkerEnv(fh.train_args['n_walkers'],
fh.train_args['position_noise'],
fh.train_args['angle_noise'],
reward_mech='global') #fh.train_args['reward_mech'])
if fh.train_args['buffer_size'] > 1:
env = ObservationBuffer(env, fh.train_args['buffer_size'])
hpolicy = None
if args.heuristic:
from heuristics.multiwalker import MultiwalkerHeuristicPolicy
hpolicy = MultiwalkerHeuristicPolicy(env.agents[0].observation_space,
env.agents[0].action_space)
if args.evaluate:
minion = Evaluator(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic,
'heuristic' if args.heuristic else fh.mode)
evr = minion(fh.filename,
file_key=fh.file_key,
same_con_pol=args.same_con_pol,
hpolicy=hpolicy)
from tabulate import tabulate
print(tabulate(evr, headers='keys'))
else:
minion = Visualizer(env, fh.train_args, args.n_steps, args.n_trajs,
args.deterministic, fh.mode)
rew, info = minion(fh.filename, file_key=fh.file_key, vid=args.vid)
pprint.pprint(rew)
pprint.pprint(info)
def setup_vis(self):
''' Returns Visualizer object initialized with 2-D bounds of problem. '''
return Visualizer(self.x_min, self.x_max, self.y_min, self.y_max, [])
for i in range(400):
T = 100
xdims = pm.xdims
udims = pm.udims
A = pm.A
B = pm.B
Q = pm.Q
R = pm.R
init_state = pm.init_state
x_f = np.array([[10], [2], [0], [0]])
u_f = np.array([[0], [0]])
sys = SystemPointMass(xdims, udims, T, A, B, stoch=True)
robot = InfRobotLTI(sys, init_state, T, Q, R, x_f=x_f, u_f=u_f)
robot.reg_lti()
states, controls, costs = robot.rollout(verbose=False)
if i == 0:
vis = Visualizer()
vis.set_recording(states)
vis.set_target(x_f)
vis.show()
# print "TOTAL COST: " + str(sum(costs))
avg_costs.append(sum(costs))
print "Avg. cost: " + str(np.mean(avg_costs))
def train(**kwargs):
# opt = Config()
for k, v in kwargs.items():
setattr(opt, k, v)
vis = Visualizer(opt.env, opt.port)
device = t.device('cuda') if opt.use_gpu else t.device('cpu')
lr = opt.lr
#网络配置
featurenet = FeatureNet(4, 5)
if opt.model_path:
featurenet.load_state_dict(
t.load(opt.model_path, map_location=lambda _s, _: _s))
featurenet.to(device)
#加载数据
data_set = dataset.FeatureDataset(root=opt.data_root,
train=True,
test=False)
dataloader = DataLoader(data_set,
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.num_workers)
val_dataset = dataset.FeatureDataset(root=opt.data_root,
train=False,
test=False)
val_dataloader = DataLoader(val_dataset,
opt.batch_size,
shuffle=False,
num_workers=opt.num_workers)
#定义优化器和随时函数
optimizer = t.optim.SGD(featurenet.parameters(), lr)
criterion = t.nn.CrossEntropyLoss().to(device)
#计算重要指标
loss_meter = AverageValueMeter()
#开始训练
for epoch in range(opt.max_epoch):
loss_meter.reset()
for ii, (data, label) in enumerate(dataloader):
feature = data.to(device)
target = label.to(device)
optimizer.zero_grad()
prob = featurenet(feature)
# print(prob)
# print(target)
loss = criterion(prob, target)
loss.backward()
optimizer.step()
loss_meter.add(loss.item())
if (ii + 1) % opt.plot_every:
vis.plot('train_loss', loss_meter.value()[0])
if os.path.exists(opt.debug_file):
import ipdb
ipdb.set_trace()
t.save(
featurenet.state_dict(),
'checkpoints/{epoch}_{time}_{loss}.pth'.format(
epoch=epoch,
time=time.strftime('%m%d_%H_%M_%S'),
loss=loss_meter.value()[0]))
#验证和可视化
accu, loss = val(featurenet, val_dataloader, criterion)
featurenet.train()
vis.plot('val_loss', loss)
vis.log('epoch: {epoch}, loss: {loss}, accu: {accu}'.format(
epoch=epoch, loss=loss, accu=accu))
lr = lr * 0.9
for param_group in optimizer.param_groups:
param_group['lr'] = lr
variance2 = []
for epsilon in epsilons:
name_config = config_file_name + '{:.2f}'.format(epsilon)[2:] + pklf
name_data = data_file_name + '{:.2f}'.format(epsilon)[2:] + csvf
solver = BayesianLearner(name_config, name_data)
# print(solver.P_g)
solver.traj_Learner()
print(solver.P_g)
data1.append(solver.P_g['g1'])
data2.append(solver.P_g['g2'])
error1_low.append(abs(solver.P_g_min['g1'] - solver.P_g['g1']))
error1_high.append(abs(solver.P_g_max['g1'] - solver.P_g['g1']))
error2_low.append(abs(solver.P_g_min['g2'] - solver.P_g['g2']))
error2_high.append(abs(solver.P_g_max['g2'] - solver.P_g['g2']))
variance1.append(25 * np.var(solver.P_g_history['g1']))
variance2.append(25 * np.var(solver.P_g_history['g2']))
error1 = [error1_low, error1_high]
error2 = [error2_low, error2_high]
# print (variance1, variance2)
print(error1)
print(error2)
VIS = Visualizer()
# VIS.plot_curve(epsilons, data1, data2, variance1, variance2, 'result')
VIS.plot_single_curve(epsilons, data1, variance1, 'result_single')
def main():
logging.basicConfig(level=args.loglevel)
if not args.random:
np.random.seed(42)
with open(args.robot_config) as f:
config = yaml.load(f.read())
robots, motions = initialize_robots_and_motions(config)
num_robots = len(robots)
vis = Visualizer(num_robots, config['motion_parameters']['disturbance'],
args.headless)
pool = multiprocessing.Pool()
elapsed = 0
while True:
# create array of pairs of robots that sent messages
long_range_measurements = []
short_range_measurements = []
for i, (robot, motion) in enumerate(zip(robots, motions)):
# Ground truth for the robots will be stored elsewhere.
control_output = robot.get_control_output()
odometry = motion.apply_control_input(control_output)
robot.receive_odometry_message(odometry)
for i in range(num_robots):
for j in range(i + 1, num_robots): # No self messages
robot1 = robots[i]
robot2 = robots[j]
motion1 = motions[i]
motion2 = motions[j]
# Potentially exchange long / short messages, and log their results
did_short_range_comm = do_long_range_message(
config, robot1, robot2, motion1, motion2)
did_long_range_comm = do_short_range_message(
config, robot1, robot2, motion1, motion2)
# if we exchanged the messages, add the indices of the pair to the visualizer
if did_short_range_comm:
short_range_measurements.append((i, j))
if did_long_range_comm:
long_range_measurements.append((i, j))
# Let each robot perform some computation at each time step.
start_time = time.time()
if args.multiprocessing:
robots = pool.map(compute_map, robots)
else:
for robot in robots:
robot.compute()
end_time = time.time()
logging.warning("Took %f seconds to perform all computation!",
end_time - start_time)
# Perform visualization update.
vis.update(robots, motions, short_range_measurements,
long_range_measurements)
# As the final step of the loop, update the timestamp for each robot.
for robot in robots:
robot.step(1)
# Potentially exit the simulation.
elapsed += 1
if args.time > 0 and elapsed >= args.time:
sys.exit(0)
# Sleep for some amount of time.
if (args.delay > 0):
time.sleep(args.delay)
elif (args.delay < 0):
input()
class Trainer():
def __init__(self, config):
# data
self.train_data = AnnPolygon(config, train=True)
self.val_data = AnnPolygon(config, train=False)
self.num_points = config.num_points
self.gt_num_points = config.gt_num_points
# model
self.model = Snake(state_dim=config.batch_size,
feature_dim=6,
conv_type='dgrid')
# Run on GPU/CPU
if torch.cuda.is_available():
self.device = torch.device(f"cuda:{config.multi_gpu[0]}")
else:
self.device = torch.device(f"cpu")
# check if load from existing model
if config.reload_model_path:
self.model.load(config.reload_model_path)
else:
self.model.cuda()
self.train_dataloader = DataLoader(self.train_data,
config.batch_size,
shuffle=True,
num_workers=config.num_workers,
drop_last=True)
self.val_dataloader = DataLoader(self.val_data,
config.batch_size,
shuffle=True,
num_workers=config.num_workers,
drop_last=True)
# optimizer
self.criterion = dist_chamfer_2D.chamfer_2DDist()
if config.optimizer == "adam":
self.lr = config.learning_rate
self.optimizer = Adam(self.model.parameters(), lr=self.lr)
elif config.optimizer == "sgd":
self.lr = config.learning_rate / 10
self.optimizer = SGD(self.model.parameters(), lr=self.lr)
self.train_loss = meter.AverageValueMeter()
self.val_loss = meter.AverageValueMeter()
self.epochs = config.epochs
self.vis = Visualizer(config)
def train(self):
for epoch in range(self.epochs):
self.train_loss.reset()
# training iteration
for i, (curve, GT) in enumerate(self.train_dataloader):
# load
GT_points = GT.type(torch.FloatTensor).cuda(device=self.device)
curve = curve.type(torch.FloatTensor).cuda(device=self.device)
coodinates = curve[:, :, :2]
curve = curve.permute(0, 2, 1)
coodinates = coodinates.permute(0, 2, 1)
# feed into model
offset = self.model(curve)
new_coodinates = offset + coodinates
dist1, dist2, _, _ = self.criterion(
GT_points, new_coodinates.permute(0, 2, 1))
loss = torch.mean(dist1) / self.num_points + torch.mean(
dist2) / self.gt_num_points
# backward
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
self.train_loss.add(loss.item())
self.vis.plot('train_loss',
self.train_loss.value()[0],
i + epoch * len(self.train_data))
self.model.eval()
for i, (curve, GT) in enumerate(self.val_dataloader):
# load data
GT_points = GT.type(torch.FloatTensor).cuda(device=self.device)
curve = curve.type(torch.FloatTensor).cuda(device=self.device)
coodinates = curve[:, :, :2]
curve = curve.permute(0, 2, 1)
coodinates = coodinates.permute(0, 2, 1)
# feed into model
offset = self.model(curve)
new_coodinates = offset + coodinates
dist1, dist2, _, _ = self.criterion(
GT_points, new_coodinates.permute(0, 2, 1))
loss = torch.mean(dist1) / self.num_points + torch.mean(
dist2) / self.gt_num_points
self.val_loss.add(loss.item())
self.vis.plot('val_loss',
self.val_loss.value()[0],
i + epoch * len(self.val_data))
self.model.train()
a[0] = hip_todo[0]
a[1] = knee_todo[0]
a[2] = hip_todo[1]
a[3] = knee_todo[1]
a = np.clip(0.5 * a, -1.0, 1.0)
actions[i, :] = a
fake_actiondist = np.concatenate(
[np.zeros((n_agents, 4)),
np.ones((n_agents, 4))])
return actions, fake_actiondist
if __name__ == '__main__':
from madrl_environments.walker.multi_walker import MultiWalkerEnv
from vis import Visualizer
import pprint
env = MultiWalkerEnv(n_walkers=3)
train_args = {'discount': 0.99, 'control': 'decentralized'}
vis = Visualizer(env, train_args, 500, 1, True, 'heuristic')
rew, info = vis(None,
hpolicy=MultiWalkerHeuristicPolicy(
env.agents[0].observation_space,
env.agents[0].observation_space))
pprint.pprint(rew)
pprint.pprint(info)
# dagger_lr = KernelRidge(kernel='rbf', gamma=100)
dagger_lr = LinearRegression(fit_intercept=False)#KernelRidge(kernel='rbf')#
dagger_learner = SKLearner(dagger_lr)
dagger_trajs, dagger_traj_controls, dagger_costs, dagger_avg_costs, dagger_avg_loss, dagger_accs = trials.dagger_trial(dagger_learner, robot, sys)
dagger_final_trajs, dagger_final_controls, dagger_final_costs, dagger_final_avg_costs, dagger_final_avg_loss = trials.dagger_final(dagger_learner, robot, sys)
dagger_data[t, :] = dagger_avg_costs
dagger_loss_data[t, :] = dagger_avg_loss
dagger_final_data[t, :] = dagger_final_avg_costs
dagger_acc_data[t, :] = dagger_accs
# print im_lr.coef_
# print dagger_lr.coef_
# print robot.lqr.K1
vis = Visualizer()
vis.show_trajs(sup_trajs, x_f, "sup_trajs", data_directory)
vis.show_trajs(im_trajs, x_f, "sl_trajs", data_directory)
vis.show_trajs(dagger_trajs, x_f, "dagger_trajs", data_directory)
vis.show_trajs(dagger_final_trajs, x_f, "dagger_final_trajs", data_directory)
print im_accs
print dagger_accs
print "\n\n\n"
for state, control in im_learner.data:
print control
print im_learner.predict(state)
print dagger_learner.predict(state)
def train(**kwargs):
for k_, v_ in kwargs.items():
setattr(config, k_, v_)
vis_ = Visualizer()
# data
train_dataset = get_data.Ali(config.train_path, 'train',
config.feature_index_path)
val_dataset = get_data.Ali(config.val_path, 'val',
config.feature_index_path)
train_loader = DataLoader(dataset=train_dataset,
batch_size=config.batch_size,
shuffle=True,
drop_last=True)
val_loader = DataLoader(dataset=val_dataset, batch_size=config.batch_size)
# model
model = deepfm.FNN(config.feature_index_path)
print(model)
# print('initializing...')
# model.apply(weight_init)
# testing
if config.test_flag:
test_dataset = get_data.Ali(config.test_path, 'test',
config.feature_index_path)
test_loader = DataLoader(dataset=test_dataset,
batch_size=config.batch_size)
model.load_state_dict(
torch.load(os.path.join(config.model_path, '_best')))
test(model, test_loader, config.output_path)
# criterion and optimizer
criterion = torch.nn.BCELoss()
lr = config.lr
optimizer = Adam(model.parameters(),
lr=lr,
betas=(config.beta1, config.beta2),
weight_decay=config.weight_decay)
previous_loss = 1e6
if torch.cuda.is_available():
model.cuda()
criterion.cuda()
# meters
loss_meter = tnt.meter.AverageValueMeter()
# class_err = tnt.meter.ClassErrorMeter()
# confusion_matrix = tnt.meter.ConfusionMeter(2, normalized=True)
# val(model, val_loader, criterion)
# resume training
start = 0
if config.resume:
model_epoch = [
int(fname.split('_')[-1])
for fname in os.listdir(config.model_path) if 'best' not in fname
]
start = max(model_epoch)
model.load_state_dict(
torch.load(os.path.join(config.model_path, '_epoch_{start}')))
if start >= config.epochs:
print('Training already Done!')
return
# train
print('start training...')
for i in range(start, config.epochs):
loss_meter.reset()
# class_err.reset()
# confusion_matrix.reset()
for ii, (c_data, labels) in tqdm(enumerate(train_loader)):
c_data = to_var(c_data)
labels = to_var(labels).float()
# labels = labels.view(-1, 1)
pred = model(c_data)
# print(pred, labels)
loss = criterion(pred, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
# meters update and visualize
loss_meter.add(loss.data[0])
# confusion_matrix.add(pred.data.squeeze(), labels.data.type(torch.LongTensor))
if (ii + 1) % config.print_every == 0:
vis_.plot('train_loss', loss_meter.value()[0])
print(
f'''epochs: {i + 1}/{config.epochs} batch: {ii + 1}/{len(train_loader)}
train_loss: {loss.data[0]}''')
print('evaluating...')
# train_cm = confusion_matrix.value()
val_cm, val_accuracy, val_loss = val(model, val_loader, criterion)
vis_.plot('val_loss', val_loss)
vis_.log(f"epoch:{start + 1},lr:{lr},loss:{val_loss}")
torch.save(model.state_dict(),
os.path.join(config.model_path, f'_epoch_{i}'))
# update learning rate
if loss_meter.value()[0] > previous_loss:
torch.save(model.state_dict(),
os.path.join(config.model_path, '_best'))
lr = lr * config.lr_decay
for param_group in optimizer.param_groups:
param_group['lr'] = lr
previous_loss = loss_meter.value()[0]
def main():
parser = argparse.ArgumentParser()
default_dataset = 'toy-data.npz'
parser.add_argument('--data', default=default_dataset,
help='data file')
parser.add_argument('--seed', type=int, default=None,
help='random seed. Randomly set if not specified.')
# training options
parser.add_argument('--nz', type=int, default=32,
help='dimension of latent variable')
parser.add_argument('--epoch', type=int, default=1000,
help='number of training epochs')
parser.add_argument('--batch-size', type=int, default=128,
help='batch size')
parser.add_argument('--lr', type=float, default=1e-4,
help='learning rate')
parser.add_argument('--min-lr', type=float, default=5e-5,
help='min learning rate for LR scheduler. '
'-1 to disable annealing')
parser.add_argument('--plot-interval', type=int, default=10,
help='plot interval. 0 to disable plotting.')
parser.add_argument('--save-interval', type=int, default=0,
help='interval to save models. 0 to disable saving.')
parser.add_argument('--prefix', default='pvae',
help='prefix of output directory')
parser.add_argument('--comp', type=int, default=5,
help='continuous convolution kernel size')
parser.add_argument('--sigma', type=float, default=.2,
help='standard deviation for Gaussian likelihood')
parser.add_argument('--overlap', type=float, default=.5,
help='kernel overlap')
# squash is off when rescale is off
parser.add_argument('--squash', dest='squash', action='store_const',
const=True, default=True,
help='bound the generated time series value '
'using tanh')
parser.add_argument('--no-squash', dest='squash', action='store_const',
const=False)
# rescale to [-1, 1]
parser.add_argument('--rescale', dest='rescale', action='store_const',
const=True, default=True,
help='if set, rescale time to [-1, 1]')
parser.add_argument('--no-rescale', dest='rescale', action='store_const',
const=False)
args = parser.parse_args()
batch_size = args.batch_size
nz = args.nz
epochs = args.epoch
plot_interval = args.plot_interval
save_interval = args.save_interval
try:
npz = np.load(args.data)
train_data = npz['data']
train_time = npz['time']
train_mask = npz['mask']
except FileNotFoundError:
if args.data != default_dataset:
raise
# Generate the default toy dataset from scratch
train_data, train_time, train_mask, _, _ = gen_data(
n_samples=10000, seq_len=200, max_time=1, poisson_rate=50,
obs_span_rate=.25, save_file=default_dataset)
_, in_channels, seq_len = train_data.shape
train_time *= train_mask
if args.seed is None:
rnd = np.random.RandomState(None)
random_seed = rnd.randint(np.iinfo(np.uint32).max)
else:
random_seed = args.seed
rnd = np.random.RandomState(random_seed)
np.random.seed(random_seed)
torch.manual_seed(random_seed)
# Scale time
max_time = 5
train_time *= max_time
squash = None
rescaler = None
if args.rescale:
rescaler = Rescaler(train_data)
train_data = rescaler.rescale(train_data)
if args.squash:
squash = torch.tanh
out_channels = 64
cconv_ref = 98
train_dataset = TimeSeries(
train_data, train_time, train_mask, label=None, max_time=max_time,
cconv_ref=cconv_ref, overlap_rate=args.overlap, device=device)
train_loader = DataLoader(
train_dataset, batch_size=batch_size, shuffle=True,
drop_last=True, collate_fn=train_dataset.collate_fn)
n_train_batch = len(train_loader)
test_batch_size = 64
test_loader = DataLoader(train_dataset, batch_size=test_batch_size,
collate_fn=train_dataset.collate_fn)
grid_decoder = SeqGeneratorDiscrete(in_channels, nz, squash)
decoder = Decoder(grid_decoder, max_time=max_time).to(device)
cconv = ContinuousConv1D(
in_channels, out_channels, max_time, cconv_ref,
overlap_rate=args.overlap, kernel_size=args.comp, norm=True).to(device)
encoder = Encoder(nz, cconv).to(device)
pvae = PVAE(encoder, decoder, sigma=args.sigma).to(device)
optimizer = optim.Adam(pvae.parameters(), lr=args.lr)
scheduler = make_scheduler(optimizer, args.lr, args.min_lr, epochs)
path = '{}_{}_{}'.format(
args.prefix, datetime.now().strftime('%m%d.%H%M%S'),
'_'.join([f'lr_{args.lr:g}']))
output_dir = Path('results') / 'toy-pvae' / path
print(output_dir)
log_dir = mkdir(output_dir / 'log')
model_dir = mkdir(output_dir / 'model')
start_epoch = 0
with (log_dir / 'seed.txt').open('w') as f:
print(random_seed, file=f)
with (log_dir / 'gpu.txt').open('a') as f:
print(torch.cuda.device_count(), start_epoch, file=f)
with (log_dir / 'args.txt').open('w') as f:
for key, val in sorted(vars(args).items()):
print(f'{key}: {val}', file=f)
tracker = Tracker(log_dir, n_train_batch)
visualizer = Visualizer(encoder, decoder, test_batch_size, max_time,
test_loader, rescaler, output_dir, device)
start = time.time()
epoch_start = start
for epoch in range(start_epoch, epochs):
loss_breakdown = defaultdict(float)
for val, idx, mask, _, cconv_graph in train_loader:
optimizer.zero_grad()
loss = pvae(val, idx, mask, cconv_graph)
loss.backward()
optimizer.step()
loss_breakdown['loss'] += loss.item()
if scheduler:
scheduler.step()
cur_time = time.time()
tracker.log(
epoch, loss_breakdown, cur_time - epoch_start, cur_time - start)
if plot_interval > 0 and (epoch + 1) % plot_interval == 0:
visualizer.plot(epoch)
model_dict = {
'pvae': pvae.state_dict(),
'epoch': epoch + 1,
'args': args,
}
torch.save(model_dict, str(log_dir / 'model.pth'))
if save_interval > 0 and (epoch + 1) % save_interval == 0:
torch.save(model_dict, str(model_dir / f'{epoch:04d}.pth'))
print(output_dir)
class OnlineTracker(object):
"""
online tracker, has some match
"""
def __init__(self):
self.kf = KalmanFilter()
self.min_ap_dist = 0.64
self.tracks = []
self.remove_tracks = []
self.track_id = 0
self.vis_tool = Visualizer("MOTDN")
def match(self, img, detections, features, frm_id):
# get track state
is_lost_arr = np.array([track.is_lost for track in self.tracks])
tracked_track_idx = np.where(is_lost_arr)[0]
lost_track_idx = np.where(is_lost_arr == False)[0]
tracked_stracks = map(lambda x: self.tracks[x], tracked_track_idx)
lost_stracks = map(lambda x: self.tracks[x], lost_track_idx)
print len(self.tracks)
self.tracks = []
# first match, we match active track with detection
## 1 匹配跟踪的轨迹
dists = matching.nearest_reid_distance(tracked_stracks,
detections,
features,
metric='euclidean')
# dist不参与运算 只是起到gating的作用 滤除过长的轨迹
dists = matching.gate_cost_matrix(self.kf, dists, tracked_stracks,
detections)
# match has format (track_id, det_id)
matches, u_track, u_detection = matching.linear_assignment(
dists, thresh=self.min_ap_dist)
for itracked, idet in matches:
print "first match is ", tracked_stracks[itracked].track_id
tracked_stracks[itracked].update(detections[idet], features[idet],
frm_id, self.kf)
self.tracks.append(tracked_stracks[itracked])
detections = [detections[idet] for idet in u_detection]
features = [features[idet] for idet in u_detection]
## 2 匹配消失的轨迹
dists = matching.nearest_reid_distance(lost_stracks,
detections,
features,
metric='euclidean')
dists = matching.gate_cost_matrix(self.kf, dists, lost_stracks,
detections)
matches, u_lost, u_detection = matching.linear_assignment(
dists, thresh=self.min_ap_dist)
for itracked, idet in matches:
print "second match is ", lost_stracks[itracked].track_id
lost_stracks[itracked].update(detections[idet], features[idet],
frm_id, self.kf)
self.tracks.append(lost_stracks[itracked])
## 3 1中未匹配的轨迹继续匹配
## 匹配方式改为IOU匹配
detections = [detections[i] for i in u_detection]
features = [features[idet] for idet in u_detection]
r_tracked_stracks = [tracked_stracks[idx] for idx in u_track]
dists = matching.iou_distance(r_tracked_stracks, detections)
matches, u_track, u_detection = matching.linear_assignment(dists,
thresh=0.7)
for itracked, idet in matches:
print "third match is ", r_tracked_stracks[itracked].track_id
r_tracked_stracks[itracked].update(detections[idet],
features[idet], frm_id, self.kf)
self.tracks.append(r_tracked_stracks[itracked])
# 未匹配到的更新
for idx in u_track:
r_tracked_stracks[idx].update(frm_id=frm_id, kalman_filter=self.kf)
self.tracks.append(r_tracked_stracks[idx])
detections = [detections[i] for i in u_detection]
features = [features[idet] for idet in u_detection]
## 4 2中未匹配的轨迹继续匹配
r_lost_stracks = [lost_stracks[idx] for idx in u_lost]
dists = matching.iou_distance(r_lost_stracks, detections)
matches, u_unconfirmed, u_detection = matching.linear_assignment(
dists, thresh=0.7)
for itracked, idet in matches:
print "forth match is ", r_lost_stracks[itracked].track_id
r_lost_stracks[itracked].update(detections[idet], features[idet],
frm_id, self.kf)
self.tracks.append(r_lost_stracks[itracked])
# check u_unconfirmed and delete it if satisfy
for idx in u_unconfirmed:
r_lost_stracks[idx].update(frm_id=frm_id, kalman_filter=self.kf)
if r_lost_stracks[idx].age >= P['max_lost_track_time']:
continue
self.tracks.append(r_lost_stracks[idx])
detections = [detections[i] for i in u_detection]
features = [features[idet] for idet in u_detection]
# 生成新的轨迹
for det, fea in zip(detections, features):
self.tracks.append(
BaseTrack(det, fea, frm_id, self.track_id, self.kf))
self.track_id += 1
def vis_track(self, img):
# raw_input()
show_thresh = 1
track_pos_list = [
track.curr_pos.astype(np.int32) for track in self.tracks
if track.age < show_thresh
]
track_color_list = [
track.color for track in self.tracks if track.age < show_thresh
]
track_id_list = [
track.track_id for track in self.tracks if track.age < show_thresh
]
track_conf_list = [
0.4 for track in self.tracks if track.age < show_thresh
]
self.vis_tool.image_track(img, track_id_list, track_pos_list,
track_color_list, track_conf_list, "track")
def main():
parser = argparse.ArgumentParser()
default_dataset = 'toy-data.npz'
parser.add_argument('--data', default=default_dataset, help='data file')
parser.add_argument('--seed',
type=int,
default=None,
help='random seed. Randomly set if not specified.')
# training options
parser.add_argument('--nz',
type=int,
default=32,
help='dimension of latent variable')
parser.add_argument('--epoch',
type=int,
default=1000,
help='number of training epochs')
parser.add_argument('--batch-size',
type=int,
default=128,
help='batch size')
parser.add_argument('--lr',
type=float,
default=8e-5,
help='encoder/decoder learning rate')
parser.add_argument('--dis-lr',
type=float,
default=1e-4,
help='discriminator learning rate')
parser.add_argument('--min-lr',
type=float,
default=5e-5,
help='min encoder/decoder learning rate for LR '
'scheduler. -1 to disable annealing')
parser.add_argument('--min-dis-lr',
type=float,
default=7e-5,
help='min discriminator learning rate for LR '
'scheduler. -1 to disable annealing')
parser.add_argument('--wd', type=float, default=0, help='weight decay')
parser.add_argument('--overlap',
type=float,
default=.5,
help='kernel overlap')
parser.add_argument('--no-norm-trans',
action='store_true',
help='if set, use Gaussian posterior without '
'transformation')
parser.add_argument('--plot-interval',
type=int,
default=1,
help='plot interval. 0 to disable plotting.')
parser.add_argument('--save-interval',
type=int,
default=0,
help='interval to save models. 0 to disable saving.')
parser.add_argument('--prefix',
default='pbigan',
help='prefix of output directory')
parser.add_argument('--comp',
type=int,
default=7,
help='continuous convolution kernel size')
parser.add_argument('--ae',
type=float,
default=.2,
help='autoencoding regularization strength')
parser.add_argument('--aeloss',
default='smooth_l1',
help='autoencoding loss. (options: mse, smooth_l1)')
parser.add_argument('--ema',
dest='ema',
type=int,
default=-1,
help='start epoch of exponential moving average '
'(EMA). -1 to disable EMA')
parser.add_argument('--ema-decay',
type=float,
default=.9999,
help='EMA decay')
parser.add_argument('--mmd',
type=float,
default=1,
help='MMD strength for latent variable')
# squash is off when rescale is off
parser.add_argument('--squash',
dest='squash',
action='store_const',
const=True,
default=True,
help='bound the generated time series value '
'using tanh')
parser.add_argument('--no-squash',
dest='squash',
action='store_const',
const=False)
# rescale to [-1, 1]
parser.add_argument('--rescale',
dest='rescale',
action='store_const',
const=True,
default=True,
help='if set, rescale time to [-1, 1]')
parser.add_argument('--no-rescale',
dest='rescale',
action='store_const',
const=False)
args = parser.parse_args()
batch_size = args.batch_size
nz = args.nz
epochs = args.epoch
plot_interval = args.plot_interval
save_interval = args.save_interval
try:
npz = np.load(args.data)
train_data = npz['data']
train_time = npz['time']
train_mask = npz['mask']
except FileNotFoundError:
if args.data != default_dataset:
raise
# Generate the default toy dataset from scratch
train_data, train_time, train_mask, _, _ = gen_data(
n_samples=10000,
seq_len=200,
max_time=1,
poisson_rate=50,
obs_span_rate=.25,
save_file=default_dataset)
_, in_channels, seq_len = train_data.shape
train_time *= train_mask
if args.seed is None:
rnd = np.random.RandomState(None)
random_seed = rnd.randint(np.iinfo(np.uint32).max)
else:
random_seed = args.seed
rnd = np.random.RandomState(random_seed)
np.random.seed(random_seed)
torch.manual_seed(random_seed)
# Scale time
max_time = 5
train_time *= max_time
squash = None
rescaler = None
if args.rescale:
rescaler = Rescaler(train_data)
train_data = rescaler.rescale(train_data)
if args.squash:
squash = torch.tanh
out_channels = 64
cconv_ref = 98
train_dataset = TimeSeries(train_data,
train_time,
train_mask,
label=None,
max_time=max_time,
cconv_ref=cconv_ref,
overlap_rate=args.overlap,
device=device)
train_loader = DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
drop_last=True,
collate_fn=train_dataset.collate_fn)
n_train_batch = len(train_loader)
time_loader = DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
drop_last=True,
collate_fn=train_dataset.collate_fn)
test_loader = DataLoader(train_dataset,
batch_size=batch_size,
collate_fn=train_dataset.collate_fn)
grid_decoder = SeqGeneratorDiscrete(in_channels, nz, squash)
decoder = Decoder(grid_decoder, max_time=max_time).to(device)
cconv = ContinuousConv1D(in_channels,
out_channels,
max_time,
cconv_ref,
overlap_rate=args.overlap,
kernel_size=args.comp,
norm=True).to(device)
encoder = Encoder(cconv, nz, not args.no_norm_trans).to(device)
pbigan = PBiGAN(encoder, decoder, args.aeloss).to(device)
critic_cconv = ContinuousConv1D(in_channels,
out_channels,
max_time,
cconv_ref,
overlap_rate=args.overlap,
kernel_size=args.comp,
norm=True).to(device)
critic = ConvCritic(critic_cconv, nz).to(device)
ema = None
if args.ema >= 0:
ema = EMA(pbigan, args.ema_decay, args.ema)
optimizer = optim.Adam(pbigan.parameters(),
lr=args.lr,
weight_decay=args.wd)
critic_optimizer = optim.Adam(critic.parameters(),
lr=args.dis_lr,
weight_decay=args.wd)
scheduler = make_scheduler(optimizer, args.lr, args.min_lr, epochs)
dis_scheduler = make_scheduler(critic_optimizer, args.dis_lr,
args.min_dis_lr, epochs)
path = '{}_{}'.format(args.prefix, datetime.now().strftime('%m%d.%H%M%S'))
output_dir = Path('results') / 'toy-pbigan' / path
print(output_dir)
log_dir = mkdir(output_dir / 'log')
model_dir = mkdir(output_dir / 'model')
start_epoch = 0
with (log_dir / 'seed.txt').open('w') as f:
print(random_seed, file=f)
with (log_dir / 'gpu.txt').open('a') as f:
print(torch.cuda.device_count(), start_epoch, file=f)
with (log_dir / 'args.txt').open('w') as f:
for key, val in sorted(vars(args).items()):
print(f'{key}: {val}', file=f)
tracker = Tracker(log_dir, n_train_batch)
visualizer = Visualizer(encoder, decoder, batch_size, max_time,
test_loader, rescaler, output_dir, device)
start = time.time()
epoch_start = start
for epoch in range(start_epoch, epochs):
loss_breakdown = defaultdict(float)
for ((val, idx, mask, _, cconv_graph),
(_, idx_t, mask_t, index, _)) in zip(train_loader, time_loader):
z_enc, x_recon, z_gen, x_gen, ae_loss = pbigan(
val, idx, mask, cconv_graph, idx_t, mask_t)
cconv_graph_gen = train_dataset.make_graph(x_gen, idx_t, mask_t,
index)
real = critic(cconv_graph, batch_size, z_enc)
fake = critic(cconv_graph_gen, batch_size, z_gen)
D_loss = gan_loss(real, fake, 1, 0)
critic_optimizer.zero_grad()
D_loss.backward(retain_graph=True)
critic_optimizer.step()
G_loss = gan_loss(real, fake, 0, 1)
mmd_loss = mmd(z_enc, z_gen)
loss = G_loss + ae_loss * args.ae + mmd_loss * args.mmd
optimizer.zero_grad()
loss.backward()
optimizer.step()
if ema:
ema.update()
loss_breakdown['D'] += D_loss.item()
loss_breakdown['G'] += G_loss.item()
loss_breakdown['AE'] += ae_loss.item()
loss_breakdown['MMD'] += mmd_loss.item()
loss_breakdown['total'] += loss.item()
if scheduler:
scheduler.step()
if dis_scheduler:
dis_scheduler.step()
cur_time = time.time()
tracker.log(epoch, loss_breakdown, cur_time - epoch_start,
cur_time - start)
if plot_interval > 0 and (epoch + 1) % plot_interval == 0:
if ema:
ema.apply()
visualizer.plot(epoch)
ema.restore()
else:
visualizer.plot(epoch)
model_dict = {
'pbigan': pbigan.state_dict(),
'critic': critic.state_dict(),
'ema': ema.state_dict() if ema else None,
'epoch': epoch + 1,
'args': args,
}
torch.save(model_dict, str(log_dir / 'model.pth'))
if save_interval > 0 and (epoch + 1) % save_interval == 0:
torch.save(model_dict, str(model_dir / f'{epoch:04d}.pth'))
print(output_dir)
def setup_vis(self):
return Visualizer(self.x_min, self.x_max, self.y_min, self.y_max,
self.map)
self.rob.observeProcCached()
self.blockMem.updateBlocks(self.rob)
self.kb.update()
self.visualize()
acts, running = self.goal.cycle()
for act in acts:
self.rob.sendCommand(act)
acts = self.goal.stop()
for act in acts:
self.rob.sendCommand(act)
if __name__ == '__main__':
SCALE = 3
setup_logger()
visualizer = Visualizer()
visualizer.start()
video_producer = mb.VideoProducer(width=320 * SCALE,
height=240 * SCALE,
want_depth=False)
agent_handlers = mb.AgentHandlers(video_producer=video_producer)
miss = mb.MissionXML(agentSections=[
mb.AgentSection(
name='Robo',
agenthandlers=agent_handlers,
)
])
world = mb.defaultworld(forceReset="true", seed="151")
#113 122 127? 128 129+? 130+? 131+?
miss.setWorld(world)
def setup_vis(self):
return Visualizer(self.x_min, self.x_max, self.y_min, self.y_max,
self.obstacles)
from BayesianLearner import BayesianLearner
from vis import Visualizer
import numpy as np
if __name__ == '__main__':
config_file_name = "graphconfig"
pklf = ".pkl"
data_file_name = "samples"
csvf = ".csv"
epsilon = 0.00
name_config = config_file_name + '{:.2f}'.format(epsilon)[2:] + pklf
name_data = data_file_name + '{:.2f}'.format(epsilon)[2:] + csvf
solver = BayesianLearner(name_config, name_data)
# print(solver.P_g)
convergence = solver.traj_Learner(early_stop=2)
epsilon = 0.27
name_config_ = config_file_name + '{:.2f}'.format(epsilon)[2:] + pklf
name_data_ = data_file_name + '{:.2f}'.format(epsilon)[2:] + csvf
solver_ = BayesianLearner(name_config_, name_data_)
convergence_ = solver_.traj_Learner(early_stop=2)
VIS = Visualizer()
VIS.plot_trajs_compare(convergence, convergence_, 'test')
A = pm.A
B = pm.B
Q = pm.Q
R = pm.R
init_state = pm.init_state
x_f = np.array([[0], [0], [0], [0]])#x_f = np.array([[10], [2], [0], [0]])
u_f = np.array([[0], [0]])
sys = SystemPointMass(xdims, udims, T, A, B, stoch=True)
robot = InfRobotLTI(sys, init_state, T, Q, R, x_f=x_f, u_f=u_f)
robot.reg_lti()
sup_states, sup_controls, sup_costs = robot.rollout(verbose=False)
vis = Visualizer()
vis.set_recording(sup_states)
vis.set_target(x_f)
vis.show()
print "LQR cost: " + str(sum(sup_costs))
"""lr = LinearRegression(fit_intercept=False)
learner = SKLearner(lr)
for i in range(4):
learner.add(states[i], controls[i])
learner.fit()
print "Fitting score: " + str(learner.score())
print "\nLearner: "
print learner.estimator.coef_
print "\nLQR: "
