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())