From 2192d72289bbf2cd069f67d3e93daf7934f886af Mon Sep 17 00:00:00 2001 From: =?utf8?q?Fran=C3=A7ois=20Fleuret?= Date: Sun, 16 Jul 2023 00:04:16 +0200 Subject: [PATCH] Update. --- main.py | 7 ++++--- tasks.py | 60 +++++++++++++++++++++++++++++++++++++++++++------------- world.py | 13 ++++++++---- 3 files changed, 59 insertions(+), 21 deletions(-) diff --git a/main.py b/main.py index 58e8046..305bd3c 100755 --- a/main.py +++ b/main.py @@ -136,7 +136,7 @@ parser.add_argument("--expr_input_file", type=str, default=None) ############################## # World options -parser.add_argument("--world_vqae_nb_epochs", type=int, default=10) +parser.add_argument("--world_vqae_nb_epochs", type=int, default=25) ###################################################################### @@ -187,9 +187,9 @@ default_args = { "nb_test_samples": 10000, }, "world": { - "nb_epochs": 5, + "nb_epochs": 10, "batch_size": 25, - "nb_train_samples": 10000, + "nb_train_samples": 125000, "nb_test_samples": 1000, }, } @@ -334,6 +334,7 @@ elif args.task == "world": nb_test_samples=args.nb_test_samples, batch_size=args.batch_size, vqae_nb_epochs=args.world_vqae_nb_epochs, + logger=log_string, device=device, ) diff --git a/tasks.py b/tasks.py index 96d0621..df3fd81 100755 --- a/tasks.py +++ b/tasks.py @@ -29,7 +29,7 @@ def masked_inplace_autoregression( batches, dynamic_ncols=True, desc=progress_bar_desc, - #total=input.size(0) // batch_size, + # total=input.size(0) // batch_size, ) with torch.autograd.no_grad(): @@ -957,6 +957,7 @@ class World(Task): nb_test_samples, batch_size, vqae_nb_epochs, + logger=None, device=torch.device("cpu"), ): self.batch_size = batch_size @@ -964,9 +965,9 @@ class World(Task): ( train_frames, - self.train_actions, + train_action_seq, test_frames, - self.test_actions, + test_action_seq, self.frame2seq, self.seq2frame, ) = world.create_data_and_processors( @@ -975,15 +976,33 @@ class World(Task): mode="first_last", nb_steps=30, nb_epochs=vqae_nb_epochs, + logger=logger, device=device, ) - self.train_input = self.frame2seq(train_frames) - self.train_input = self.train_input.reshape(self.train_input.size(0) // 2, -1) - self.test_input = self.frame2seq(test_frames) - self.test_input = self.test_input.reshape(self.test_input.size(0) // 2, -1) + print(f"{train_action_seq.size()=}") - self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1 + train_frame_seq = self.frame2seq(train_frames) + test_frame_seq = self.frame2seq(test_frames) + + nb_frame_codes = max(train_frame_seq.max(), test_frame_seq.max()) + 1 + nb_action_codes = max(train_action_seq.max(), test_action_seq.max()) + 1 + + self.len_frame_seq = train_frame_seq.size(1) + self.len_action_seq = train_action_seq.size(1) + self.nb_codes = nb_frame_codes + nb_action_codes + + train_frame_seq = train_frame_seq.reshape(train_frame_seq.size(0) // 2, 2, -1) + train_action_seq += nb_frame_codes + self.train_input = torch.cat( + (train_frame_seq[:, 0, :], train_action_seq, train_frame_seq[:, 1, :]), 1 + ) + + test_frame_seq = test_frame_seq.reshape(test_frame_seq.size(0) // 2, 2, -1) + test_action_seq += nb_frame_codes + self.test_input = torch.cat( + (test_frame_seq[:, 0, :], test_action_seq, test_frame_seq[:, 1, :]), 1 + ) def batches(self, split="train", nb_to_use=-1, desc=None): assert split in {"train", "test"} @@ -1003,11 +1022,16 @@ class World(Task): def produce_results( self, n_epoch, model, result_dir, logger, deterministic_synthesis ): - l = self.train_input.size(1) - k = torch.arange(l, device=self.device)[None, :] - result = self.test_input[:64].clone() + k = torch.arange( + 2 * self.len_frame_seq + self.len_action_seq, device=self.device + )[None, :] + + input = self.test_input[:64] + result = input.clone() - ar_mask = (k >= l // 2).long().expand_as(result) + ar_mask = ( + (k >= self.len_frame_seq + self.len_action_seq).long().expand_as(result) + ) result *= 1 - ar_mask masked_inplace_autoregression( @@ -1019,14 +1043,22 @@ class World(Task): device=self.device, ) - result = result.reshape(result.size(0) * 2, -1) + seq_start = input[:, : self.len_frame_seq] + seq_end = input[:, self.len_frame_seq + self.len_action_seq :] + seq_predicted = result[:, self.len_frame_seq + self.len_action_seq :] + + result = torch.cat( + (seq_start[:, None, :], seq_end[:, None, :], seq_predicted[:, None, :]), 1 + ) + result = result.reshape(-1, result.size(-1)) + print(f"{result.size()=}") frames = self.seq2frame(result) image_name = os.path.join(result_dir, f"world_result_{n_epoch:04d}.png") torchvision.utils.save_image( frames.float() / (world.Box.nb_rgb_levels - 1), image_name, - nrow=8, + nrow=12, padding=1, pad_value=0.0, ) diff --git a/world.py b/world.py index 5c21fad..fb8609d 100755 --- a/world.py +++ b/world.py @@ -72,8 +72,12 @@ def train_encoder( lr_end=1e-4, nb_epochs=10, batch_size=25, + logger=None, device=torch.device("cpu"), ): + if logger is None: + logger = lambda s: print(s) + mu, std = train_input.float().mean(), train_input.float().std() def encoder_core(depth, dim): @@ -132,7 +136,7 @@ def train_encoder( nb_parameters = sum(p.numel() for p in model.parameters()) - print(f"nb_parameters {nb_parameters}") + logger(f"nb_parameters {nb_parameters}") model.to(device) @@ -179,7 +183,7 @@ def train_encoder( train_loss = acc_train_loss / train_input.size(0) test_loss = acc_test_loss / test_input.size(0) - print(f"train_ae {k} lr {lr} train_loss {train_loss} test_loss {test_loss}") + logger(f"train_ae {k} lr {lr} train_loss {train_loss} test_loss {test_loss}") sys.stdout.flush() return encoder, quantizer, decoder @@ -326,7 +330,7 @@ def generate_episodes(nb, steps): for n in tqdm.tqdm(range(nb), dynamic_ncols=True, desc="world-data"): frames, actions = generate_episode(steps) all_frames += frames - all_actions += [actions] + all_actions += [actions[None, :]] return torch.cat(all_frames, 0).contiguous(), torch.cat(all_actions, 0) @@ -337,6 +341,7 @@ def create_data_and_processors( nb_steps, nb_epochs=10, device=torch.device("cpu"), + logger=None, ): assert mode in ["first_last"] @@ -349,7 +354,7 @@ def create_data_and_processors( test_input, test_actions = test_input.to(device), test_actions.to(device) encoder, quantizer, decoder = train_encoder( - train_input, test_input, nb_epochs=nb_epochs, device=device + train_input, test_input, nb_epochs=nb_epochs, logger=logger, device=device ) encoder.train(False) quantizer.train(False) -- 2.39.5