def test_pong_single_env(self):
args = parser.parse_args([
"--env-id",
"CompetitivePong-v0",
"--max-steps",
"2000",
"--num-envs",
"1",
"--algo",
"PPO",
])
train(args)
def test_pong_tournament_multiple(self):
args = parser.parse_args([
"--env-id",
"CompetitivePongTournament-v0",
"--max-steps",
"6000",
"--num-envs",
"3",
"--algo",
"PPO",
])
train(args)
def test_pong_multiple_env(self):
args = parser.parse_args([
"--env-id",
"CompetitivePong-v0",
"--max-steps",
"600",
"--num-envs",
"3",
"--algo",
"A2C",
])
train(args)
def test_cartpole_multiple_env(self):
args = parser.parse_args([
"--env-id",
"CartPole-v0",
"--max-steps",
"6000",
"--num-envs",
"3",
"--algo",
"PPO",
])
train(args)
def test_single_env_pong():
args = parser.parse_args([
"--env-id",
"cPong-v0",
"--max-steps",
"6000",
"--num-envs",
"1",
"--algo",
"PPO",
])
train(args)
def test_cartpole_single_env(self):
args = parser.parse_args([
"--env-id",
"CartPole-v0",
"--max-steps",
"200",
"--num-envs",
"1",
"--algo",
"A2C",
])
train(args)
def test_multiple_env_car_racing():
args = parser.parse_args([
"--env-id",
"cCarRacing-v0",
"--max-steps",
"10000",
"--num-envs",
"3",
"--algo",
"PPO",
])
train(args)
def test_pong_tournament_single(self):
args = parser.parse_args([
"--env-id",
"cPongTournament-v0",
"--max-steps",
"2000",
"--num-envs",
"1",
"--algo",
"PPO",
])
train(args)
def test_pong_multiple_env(self):
args = parser.parse_args([
"--env-id",
"cPong-v0",
"--max-steps",
"6000",
"--num-envs",
"1",
"--algo",
"PPO",
])
train(args)
def test_pong_single_env(self):
args = parser.parse_args([
"--env-id",
"cPong-v0",
"--max-steps",
"200",
"--num-envs",
"1",
"--algo",
"A2C",
])
train(args)
def main():
# ====== set the run settings ======
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
# os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
os.environ["CUDA_VISIBLE_DEVICES"]="0,1"
args = parser.parse_args()
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
folder_dir = set_project_folder_dir(args.open_new_folder, args.model_dir, use_model_folder_dir=True, mode='test')
print('The setting of the run are:\n{}\n' .format(args))
print('The training would take place on {}\n'.format(device))
print('The project directory is {}' .format(folder_dir))
save_setting_info(args, device, folder_dir)
test_videos_names, labels, label_decoder_dict = load_test_data(args.model_dir)
dataset = CMCDataset(args.sampled_data_dir, [test_videos_names, labels], mode='test')
dataloader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
# ======= if args.load_all_data_to_RAM True load dataset directly to the RAM (for faster computation) ======
if args.load_all_data_to_RAM:
dataloader = load_all_dataset_to_RAM_test(dataloader, args.batch_size)
plot_label_distribution(dataloader, folder_dir, args.load_all_data_to_RAM, label_decoder_dict, mode='test')
print('Data prepared\nLoading model...')
num_class = len(label_decoder_dict) if args.number_of_classes is None else args.number_of_classes
model = ConvLstm(args.latent_dim, args.model, args.hidden_size, args.lstm_layers, args.bidirectional, num_class)
model = model.to(device)
# ====== setting optimizer and criterion parameters ======
criterion = nn.CrossEntropyLoss()
checkpoint = torch.load(os.path.join(args.model_dir, args.model_name))
model.load_state_dict(checkpoint['model_state_dict'])
model = nn.DataParallel(model, device_ids=[0,1]).cuda()
# ====== inference_mode ======
test_loss, test_acc, predicted_labels, images, true_labels, index = test_model(model, dataloader, device, criterion,
mode='save_prediction_label_list')
print('test loss {:.8f}, test_acc {:.3f}'.format(test_loss, test_acc))
save_loss_info_into_a_file(0, test_loss, 0, test_acc, folder_dir, 'test')
# ====== analyze the test results ======
plot_images_with_predicted_labels(images, label_decoder_dict, predicted_labels[-1], folder_dir, 'test')
save_path_plots = os.path.join(folder_dir, 'Plots')
create_folder_dir_if_needed(save_path_plots)
for i in range(len(images)):
create_video_with_labels(folder_dir, '{}.avi'.format(dataset.images[index[i]].split('/')[1]),
images[i], None, [predicted_labels[-1][i]], label_decoder_dict, mode='single_movie')
predicted_labels, true_labels = torch.cat(predicted_labels), torch.cat(true_labels)
plot_confusion_matrix(predicted_labels, true_labels, label_decoder_dict, save_path_plots)
plot_acc_per_class(predicted_labels, true_labels, label_decoder_dict, save_path_plots)
def main():
global args, best_error, n_iter, device
args = parser.parse_args()
save_path = save_path_formatter(args, parser)
args.save_path = 'checkpoints_shifted' / save_path
print('=> will save everything to {}'.format(args.save_path))
args.save_path.makedirs_p()
torch.manual_seed(args.seed)
training_writer = SummaryWriter(args.save_path)
output_writers = []
if args.log_output:
for i in range(3):
output_writers.append(
SummaryWriter(args.save_path / 'valid' / str(i)))
# Data loading code
normalize = custom_transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
train_transform = custom_transforms.Compose([
custom_transforms.RandomHorizontalFlip(),
custom_transforms.RandomScaleCrop(),
custom_transforms.ArrayToTensor(), normalize
])
valid_transform = custom_transforms.Compose(
[custom_transforms.ArrayToTensor(), normalize])
print("=> fetching scenes in '{}'".format(args.data))
train_set = ShiftedSequenceFolder(
args.data,
transform=train_transform,
seed=args.seed,
train=True,
sequence_length=args.sequence_length,
target_displacement=args.target_displacement)
# if no Groundtruth is avalaible, Validation set is the same type as training set to measure photometric loss from warping
if args.with_gt:
from datasets.validation_folders import ValidationSet
val_set = ValidationSet(args.data, transform=valid_transform)
else:
val_set = SequenceFolder(
args.data,
transform=valid_transform,
seed=args.seed,
train=False,
sequence_length=args.sequence_length,
)
print('{} samples found in {} train scenes'.format(len(train_set),
len(train_set.scenes)))
print('{} samples found in {} valid scenes'.format(len(val_set),
len(val_set.scenes)))
train_loader = torch.utils.data.DataLoader(train_set,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
adjust_loader = torch.utils.data.DataLoader(
train_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=0,
pin_memory=True
) # workers is set to 0 to avoid multiple instances to be modified at the same time
val_loader = torch.utils.data.DataLoader(val_set,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if args.epoch_size == 0:
args.epoch_size = len(train_loader)
train.args = args
# create model
print("=> creating model")
disp_net = models.DispNetS().cuda()
output_exp = args.mask_loss_weight > 0
if not output_exp:
print("=> no mask loss, PoseExpnet will only output pose")
pose_exp_net = models.PoseExpNet(
nb_ref_imgs=args.sequence_length - 1,
output_exp=args.mask_loss_weight > 0).to(device)
if args.pretrained_exp_pose:
print("=> using pre-trained weights for explainabilty and pose net")
weights = torch.load(args.pretrained_exp_pose)
pose_exp_net.load_state_dict(weights['state_dict'], strict=False)
else:
pose_exp_net.init_weights()
if args.pretrained_disp:
print("=> using pre-trained weights for Dispnet")
weights = torch.load(args.pretrained_disp)
disp_net.load_state_dict(weights['state_dict'])
else:
disp_net.init_weights()
cudnn.benchmark = True
disp_net = torch.nn.DataParallel(disp_net)
pose_exp_net = torch.nn.DataParallel(pose_exp_net)
print('=> setting adam solver')
parameters = chain(disp_net.parameters(), pose_exp_net.parameters())
optimizer = torch.optim.Adam(parameters,
args.lr,
betas=(args.momentum, args.beta),
weight_decay=args.weight_decay)
with open(args.save_path / args.log_summary, 'w') as csvfile:
writer = csv.writer(csvfile, delimiter='\t')
writer.writerow(['train_loss', 'validation_loss'])
with open(args.save_path / args.log_full, 'w') as csvfile:
writer = csv.writer(csvfile, delimiter='\t')
writer.writerow(
['train_loss', 'photo_loss', 'explainability_loss', 'smooth_loss'])
logger = TermLogger(n_epochs=args.epochs,
train_size=min(len(train_loader), args.epoch_size),
valid_size=len(val_loader))
logger.epoch_bar.start()
for epoch in range(args.epochs):
logger.epoch_bar.update(epoch)
# train for one epoch
logger.reset_train_bar()
train_loss = train(args, train_loader, disp_net, pose_exp_net,
optimizer, args.epoch_size, logger, training_writer)
logger.train_writer.write(' * Avg Loss : {:.3f}'.format(train_loss))
if (epoch + 1) % 5 == 0:
train_set.adjust = True
logger.reset_train_bar(len(adjust_loader))
average_shifts = adjust_shifts(args, train_set, adjust_loader,
pose_exp_net, epoch, logger,
training_writer)
shifts_string = ' '.join(
['{:.3f}'.format(s) for s in average_shifts])
logger.train_writer.write(
' * adjusted shifts, average shifts are now : {}'.format(
shifts_string))
for i, shift in enumerate(average_shifts):
training_writer.add_scalar('shifts{}'.format(i), shift, epoch)
train_set.adjust = False
# evaluate on validation set
logger.reset_valid_bar()
if args.with_gt:
errors, error_names = validate_with_gt(args, val_loader, disp_net,
epoch, logger,
output_writers)
else:
errors, error_names = validate_without_gt(args, val_loader,
disp_net, pose_exp_net,
epoch, logger,
output_writers)
error_string = ', '.join('{} : {:.3f}'.format(name, error)
for name, error in zip(error_names, errors))
logger.valid_writer.write(' * Avg {}'.format(error_string))
for error, name in zip(errors, error_names):
training_writer.add_scalar(name, error, epoch)
# Up to you to chose the most relevant error to measure your model's performance, careful some measures are to maximize (such as a1,a2,a3)
decisive_error = errors[0]
if best_error < 0:
best_error = decisive_error
# remember lowest error and save checkpoint
is_best = decisive_error < best_error
best_error = min(best_error, decisive_error)
save_checkpoint(args.save_path, {
'epoch': epoch + 1,
'state_dict': disp_net.module.state_dict()
}, {
'epoch': epoch + 1,
'state_dict': pose_exp_net.module.state_dict()
}, is_best)
with open(args.save_path / args.log_summary, 'a') as csvfile:
writer = csv.writer(csvfile, delimiter='\t')
writer.writerow([train_loss, decisive_error])
logger.epoch_bar.finish()
def main():
args = vars(parser.parse_args())
mode = args['mode']
if mode == 'selfplay':
selfplay = True
else:
selfplay = False
one_sentence_mode = args['one_sentence_data_set']
run_default_config = configs.get_run_config(args)
folder_dir = run_default_config.folder_dir
agent_config = configs.get_agent_config(args)
game_config = configs.get_game_config(args)
utterance_config = configs.get_utterance_config()
training_config = configs.get_training_config(args, folder_dir)
corpus = data.WordCorpus('data' + os.sep, freq_cutoff=20, verbose=True)
agent = AgentModule(agent_config, utterance_config, corpus,
run_default_config.creating_data_set_mode,
run_default_config.create_utterance_using_old_code)
utter = Utterance(agent_config.action_processor, utterance_config, corpus,
run_default_config.create_utterance_using_old_code)
if not mode == "train_utter":
folder_dir_fb_model = utterance_config.fb_dir
with open(folder_dir_fb_model, 'rb') as f:
utter.load_state_dict(torch.load(f))
action = ActionModule(agent_config.action_processor, utterance_config,
corpus,
run_default_config.create_utterance_using_old_code)
create_data_set = PredefinedUtterancesModule()
if one_sentence_mode:
num_agents = np.random.randint(game_config.min_agents,
game_config.max_agents + 1)
num_landmarks = np.random.randint(game_config.min_landmarks,
game_config.max_landmarks + 1)
agent.reset()
game = GameModule(game_config, num_agents, num_landmarks, folder_dir)
df_utterance = [
pd.DataFrame(index=range(game.batch_size),
columns=agent.df_utterance_col_name,
dtype=np.int64) for i in range(game.num_agents)
]
iter = random.randint(0, game.time_horizon)
df_utterance = create_data_set.generate_sentences(game,
iter,
df_utterance,
one_sentence_mode,
mode=mode)
for epoch in range(training_config.num_epochs):
if not one_sentence_mode:
num_agents = np.random.randint(game_config.min_agents,
game_config.max_agents + 1)
num_landmarks = np.random.randint(game_config.min_landmarks,
game_config.max_landmarks + 1)
agent.reset()
game = GameModule(game_config, num_agents, num_landmarks,
folder_dir)
df_utterance = [
pd.DataFrame(index=range(game.batch_size),
columns=agent.df_utterance_col_name,
dtype=np.int64) for i in range(game.num_agents)
]
iter = random.randint(0, game.time_horizon)
df_utterance = create_data_set.generate_sentences(
game, iter, df_utterance, one_sentence_mode, mode=mode)
agent_num = random.randint(0, game.num_agents - 1)
physical_feat = agent.get_physical_feat(game, agent_num)
mem = Variable(
torch.zeros(game.batch_size, game.num_agents,
game_config.memory_size)[:, agent_num])
utterance_feat = torch.zeros([game.batch_size, 1, 256],
dtype=torch.float)
goal = game.observed_goals[:, agent_num]
processed, mem = action.processed_data(physical_feat, goal, mem,
utterance_feat)
if selfplay and one_sentence_mode:
processed = torch.load(args['folder_dir'] + os.sep +
'processed.pt')
elif not selfplay and one_sentence_mode:
torch.save(processed, args['folder_dir'] + os.sep + 'processed.pt')
full_sentence = df_utterance[agent_num]['Full Sentence' + str(iter)]
if selfplay:
loss, utterance, _ = utter(processed, full_sentence, epoch=epoch)
with open(folder_dir + os.sep +
"utterance_selfplay_annotation.csv",
'a',
newline='') as f:
for index in range(len(utterance)):
f.write(' '.join(
corpus.word_dict.i2w(utterance[index].data.cpu())))
f.write(" " + 'agent_color' + " " + colors_dict[
df_utterance[agent_num]['agent_color'][index]])
f.write(" " + 'agent_shape' + " " + shapes_dict[
df_utterance[agent_num]['agent_shape'][index]])
f.write(" " + 'lm_color' + " " + colors_dict[
df_utterance[agent_num]['lm_color'][index]])
f.write(" " + 'lm_shape' + " " + shapes_dict[
df_utterance[agent_num]['lm_shape'][index]])
f.write('\n')
else:
loss, utterance, folder_dir = utter(processed,
full_sentence,
epoch=epoch)
with open(folder_dir + os.sep + "utterance_out_fb.csv",
'a',
newline='') as f:
f.write("-----")
f.write(full_sentence[1])
f.write("----")
f.write(colors_dict[df_utterance[agent_num]['agent_color'][1]])
f.write(" " + str(df_utterance[agent_num]['dist'][1]))
f.write(" " + str(iter))
f.write('\n')
if mode == 'train_utter':
with open(training_config.save_model_file, 'wb') as f:
torch.save(utter.state_dict(), f)
print("Saved agent model weights at %s" % training_config.save_model_file)
import torch
from modules.agent import AgentModule
import configs
from train import parser
args = vars(parser.parse_args())
agent_config = configs.get_agent_config(args)
agent = AgentModule(agent_config)
agent.load_state_dict(
torch.load(
r'C:\Users\user\Desktop\emergent-language\2249-08042019\modules_weights.pt'
))
agent.eval()
for param_tensor in agent.state_dict():
print(param_tensor, "\t", agent.state_dict()[param_tensor].size())
