X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=main.py;h=6e8ebff6ad9bd449e1e8f5b144ac6eab4016b328;hb=a35b7a5ebee0b58fc76b64c13d7550eb71bc4567;hp=5b18985836a4a9e9f4dfa7ca44fa94d85ddb003f;hpb=2291d49b22390de22cfb027ac14d56ce41847adc;p=picoclvr.git

diff --git a/main.py b/main.py
index 5b18985..6e8ebff 100755
--- a/main.py
+++ b/main.py
@@ -30,6 +30,8 @@ parser = argparse.ArgumentParser(
     description="An implementation of GPT with cache to solve a toy geometric reasoning task."
 )
 
+parser.add_argument("--task", type=str, default="picoclvr")
+
 parser.add_argument("--log_filename", type=str, default="train.log")
 
 parser.add_argument("--result_dir", type=str, default="results_default")
@@ -38,17 +40,17 @@ parser.add_argument("--seed", type=int, default=0)
 
 parser.add_argument("--nb_epochs", type=int, default=25)
 
-parser.add_argument("--batch_size", type=int, default=100)
+parser.add_argument("--batch_size", type=int, default=25)
+
+parser.add_argument("--nb_train_samples", type=int, default=250000)
 
-parser.add_argument("--data_size", type=int, default=-1)
+parser.add_argument("--nb_test_samples", type=int, default=10000)
 
 parser.add_argument("--optim", type=str, default="adam")
 
-parser.add_argument("--learning_rate", type=float, default=1e-3)
+parser.add_argument("--learning_rate", type=float, default=1e-4)
 
-parser.add_argument(
-    "--learning_rate_schedule", type=str, default="10: 2e-4,20: 4e-5,30: 8e-6"
-)
+parser.add_argument("--learning_rate_schedule", type=str, default="10: 2e-5,30: 4e-6")
 
 parser.add_argument("--dim_model", type=int, default=512)
 
@@ -73,19 +75,39 @@ parser.add_argument("--checkpoint_name", type=str, default="checkpoint.pth")
 ##############################
 # picoclvr options
 
-parser.add_argument("--nb_colors", type=int, default=5)
+parser.add_argument("--picoclvr_nb_colors", type=int, default=5)
+
+parser.add_argument("--picoclvr_height", type=int, default=12)
+
+parser.add_argument("--picoclvr_width", type=int, default=16)
 
-parser.add_argument("--height", type=int, default=12)
+parser.add_argument("--picocvlr_prune_properties", type=str, default="none")
 
-parser.add_argument("--width", type=int, default=16)
+##############################
+# Maze options
+
+parser.add_argument("--maze_height", type=int, default=13)
+
+parser.add_argument("--maze_width", type=int, default=21)
 
-parser.add_argument("--prune_properties", type=str, default="none")
+parser.add_argument("--maze_nb_walls", type=int, default=15)
+
+##############################
+# Snake options
+
+parser.add_argument("--snake_height", type=int, default=6)
+
+parser.add_argument("--snake_width", type=int, default=8)
+
+parser.add_argument("--snake_nb_colors", type=int, default=3)
+
+parser.add_argument("--snake_length", type=int, default=100)
 
 ######################################################################
 
 args = parser.parse_args()
 
-assert args.prune_properties in {"none", "train+eval", "eval"}
+assert args.picocvlr_prune_properties in {"none", "train+eval", "eval"}
 
 try:
     os.mkdir(args.result_dir)
@@ -94,7 +116,7 @@ except FileExistsError:
         print(f"result directory {args.result_dir} already exists")
         exit(1)
 
-log_file = open(os.path.join(args.result_dir, args.log_filename), "w")
+log_file = open(os.path.join(args.result_dir, args.log_filename), "a")
 
 if args.seed >= 0:
     # torch.backends.cudnn.deterministic = True
@@ -127,7 +149,6 @@ for n in vars(args):
 def masked_inplace_autoregression(
     model, batch_size, input, ar_mask, forbidden_tokens=None, device=torch.device("cpu")
 ):
-
     for input, ar_mask in zip(input.split(batch_size), ar_mask.split(batch_size)):
         i = (ar_mask.sum(0) > 0).nonzero()
         if i.min() > 0:
@@ -167,7 +188,6 @@ import picoclvr
 
 
 class TaskPicoCLVR(Task):
-
     # Make a tensor from a list of strings
     def tensorize(self, descr):
         token_descr = [s.strip().split(" ") for s in descr]
@@ -277,6 +297,8 @@ class TaskPicoCLVR(Task):
 
     def __init__(
         self,
+        nb_train_samples,
+        nb_test_samples,
         batch_size,
         height,
         width,
@@ -298,12 +320,12 @@ class TaskPicoCLVR(Task):
         self.width = width
         self.batch_size = batch_size
         self.device = device
-        nb = args.data_size if args.data_size > 0 else 250000
         self.pruner_train = pruner_train
         self.pruner_eval = pruner_eval
 
         param = {
-            "nb": nb,
+            "nb_train_samples": nb_train_samples,
+            "nb_test_samples": nb_test_samples,
             "height": height,
             "width": width,
             "nb_colors": nb_colors,
@@ -311,11 +333,13 @@ class TaskPicoCLVR(Task):
             "rng_state": list(torch.get_rng_state()),
         }
 
-        log_string(f"generating {nb} samples (can take some time)")
+        log_string(
+            f"generating {nb_train_samples+nb_test_samples} samples (can take some time)"
+        )
         self.train_descr = generate_descr(
-            (nb * 4) // 5, "train", pruner=self.pruner_train
+            nb_train_samples, "train", pruner=self.pruner_train
         )
-        self.test_descr = generate_descr((nb * 1) // 5, "test", pruner=None)
+        self.test_descr = generate_descr(nb_test_samples, "test", pruner=None)
 
         # Build the tokenizer
         tokens = {"<nul>", "<img>"}
@@ -346,7 +370,6 @@ class TaskPicoCLVR(Task):
         return len(self.token2id)
 
     def compute_missing_properties(self, n_epoch, model, pruner=None):
-
         acc_nb_requested_properties = []
         acc_nb_missing_properties = []
         acc_nb_results = 0
@@ -385,7 +408,6 @@ class TaskPicoCLVR(Task):
     ######################################################################
 
     def produce_results(self, n_epoch, model):
-
         self.compute_missing_properties(n_epoch, model)
 
         if self.pruner_eval is not None:
@@ -440,7 +462,7 @@ class TaskPicoCLVR(Task):
                     0,
                 )
 
-        image_name = os.path.join(args.result_dir, f"result_{n_epoch:04d}.png")
+        image_name = os.path.join(args.result_dir, f"picoclvr_result_{n_epoch:04d}.png")
         torchvision.utils.save_image(
             img / 255.0, image_name, nrow=nb_per_primer, padding=1, pad_value=1.0
         )
@@ -449,27 +471,350 @@ class TaskPicoCLVR(Task):
 
 ######################################################################
 
-log_string(f"device {device}")
 
+class TaskMNIST(Task):
+    def __init__(self, batch_size, device=torch.device("cpu")):
+        self.device = device
+        self.batch_size = batch_size
+
+    def batches(self, split="train"):
+        assert split in {"train", "test"}
+        data_set = torchvision.datasets.MNIST(
+            root="./data", train=(split == "train"), download=True
+        )
+        data_input = data_set.data.view(-1, 28 * 28).long()
+        if args.nb_train_samples is not None:
+            data_input = data_input[: args.nb_train_samples]
+        for batch in tqdm.tqdm(
+            data_input.split(self.batch_size), desc=f"epoch-{split}"
+        ):
+            yield batch
+
+    def vocabulary_size(self):
+        return 256
+
+    def produce_results(self, n_epoch, model):
+        results = torch.empty(64, 28 * 28, device=self.device, dtype=torch.int64)
+        ar_mask = torch.full_like(results, 1)
+        masked_inplace_autoregression(
+            model, self.batch_size, results, ar_mask, device=self.device
+        )
+        image_name = os.path.join(args.result_dir, f"result_mnist_{n_epoch:04d}.png")
+        torchvision.utils.save_image(
+            1 - results.reshape(-1, 1, 28, 28) / 255.0,
+            image_name,
+            nrow=16,
+            pad_value=0.8,
+        )
+        log_string(f"wrote {image_name}")
+
+
+######################################################################
+
+import maze
+
+
+class TaskMaze(Task):
+    def map2seq(self, *m):
+        return torch.cat([x.flatten(1) for x in m], 1)
+
+    def seq2map(self, s):
+        s = s.reshape(s.size(0), -1, self.height, self.width)
+        return (s[:, k] for k in range(s.size(1)))
+
+    def __init__(
+        self,
+        nb_train_samples,
+        nb_test_samples,
+        batch_size,
+        height,
+        width,
+        nb_walls,
+        device=torch.device("cpu"),
+    ):
+        self.batch_size = batch_size
+        self.height = height
+        self.width = width
+        self.device = device
+
+        train_mazes, train_paths, _ = maze.create_maze_data(
+            nb_train_samples,
+            height=height,
+            width=width,
+            nb_walls=nb_walls,
+            progress_bar=lambda x: tqdm.tqdm(x, dynamic_ncols=True, desc=f"data-train"),
+        )
+        self.train_input = self.map2seq(train_mazes.to(device), train_paths.to(device))
+
+        test_mazes, test_paths, _ = maze.create_maze_data(
+            nb_test_samples,
+            height=height,
+            width=width,
+            nb_walls=nb_walls,
+            progress_bar=lambda x: tqdm.tqdm(x, dynamic_ncols=True, desc=f"data-test"),
+        )
+        self.test_input = self.map2seq(test_mazes.to(device), test_paths.to(device))
+
+        self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1
+
+    def batches(self, split="train", nb_to_use=-1, desc=None):
+        assert split in {"train", "test"}
+        input = self.train_input if split == "train" else self.test_input
+        if nb_to_use > 0:
+            input = input[:nb_to_use]
+        if desc is None:
+            desc = f"epoch-{split}"
+        for batch in tqdm.tqdm(
+            input.split(self.batch_size), dynamic_ncols=True, desc=desc
+        ):
+            yield batch
+
+    def vocabulary_size(self):
+        return self.nb_codes
+
+    def compute_error(self, model, split="train", nb_to_use=-1):
+        nb_total, nb_correct = 0, 0
+        for input in task.batches(split, nb_to_use):
+            result = input.clone()
+            ar_mask = result.new_zeros(result.size())
+            ar_mask[:, self.height * self.width :] = 1
+            result *= 1 - ar_mask
+            masked_inplace_autoregression(
+                model, self.batch_size, result, ar_mask, device=self.device
+            )
+            mazes, paths = self.seq2map(result)
+            nb_correct += maze.path_correctness(mazes, paths).long().sum()
+            nb_total += mazes.size(0)
+
+        return nb_total, nb_correct
+
+    def produce_results(self, n_epoch, model):
+        with torch.autograd.no_grad():
+            t = model.training
+            model.eval()
+
+            train_nb_total, train_nb_correct = self.compute_error(
+                model, "train", nb_to_use=1000
+            )
+            log_string(
+                f"accuracy_train nb_total {train_nb_total} nb_correct {train_nb_correct} accuracy {(100.0*train_nb_correct)/train_nb_total:.02f}%"
+            )
+
+            test_nb_total, test_nb_correct = self.compute_error(
+                model, "test", nb_to_use=1000
+            )
+            log_string(
+                f"accuracy_test nb_total {test_nb_total} nb_correct {test_nb_correct} accuracy {(100.0*test_nb_correct)/test_nb_total:.02f}%"
+            )
+
+            input = self.test_input[:48]
+            result = input.clone()
+            ar_mask = result.new_zeros(result.size())
+            ar_mask[:, self.height * self.width :] = 1
+            result *= 1 - ar_mask
+            masked_inplace_autoregression(
+                model, self.batch_size, result, ar_mask, device=self.device
+            )
+
+            mazes, paths = self.seq2map(input)
+            _, predicted_paths = self.seq2map(result)
+
+            filename = os.path.join(args.result_dir, f"result_{n_epoch:04d}.png")
+            maze.save_image(
+                filename,
+                mazes=mazes,
+                target_paths=paths,
+                predicted_paths=predicted_paths,
+                path_correct=maze.path_correctness(mazes, predicted_paths),
+            )
+            log_string(f"wrote {filename}")
+
+            model.train(t)
+
+
+######################################################################
 
-def pruner_horizontal_green(p):
+
+def generate_snake_sequences(
+    nb, height, width, nb_colors, length, device=torch.device("cpu")
+):
+    worlds = torch.randint(nb_colors, (nb, height, width), device=device)
+    # nb x 2
+    snake_position = torch.cat(
+        (
+            torch.randint(height, (nb, 1), device=device),
+            torch.randint(width, (nb, 1), device=device),
+        ),
+        1,
+    )
+    snake_direction = torch.randint(4, (nb,), device=device)
+    sequences = torch.empty(nb, 2 * length, device=device, dtype=torch.int64)
+    count = torch.arange(nb, device=device)  # [:,None]
+
+    for l in range(length):
+        # nb x 3
+        snake_next_direction = torch.cat(
+            (
+                (snake_direction[:, None] - 1) % 4,
+                snake_direction[:, None],
+                (snake_direction[:, None] + 1) % 4,
+            ),
+            1,
+        )
+
+        # nb x 3
+        vh = (snake_next_direction + 1) % 2 * (snake_next_direction - 1)
+        vw = snake_next_direction % 2 * (snake_next_direction - 2)
+
+        # nb x 3 x 2
+        snake_next_speed = torch.cat((vh[:, :, None], vw[:, :, None]), 2)
+        snake_next_position = snake_position[:, None, :] + snake_next_speed
+
+        # nb x 3
+        val = torch.logical_and(
+            torch.logical_and(
+                snake_next_position[:, :, 0] >= 0, snake_next_position[:, :, 0] < height
+            ),
+            torch.logical_and(
+                snake_next_position[:, :, 1] >= 0, snake_next_position[:, :, 1] < width
+            ),
+        ).float()
+        val = (
+            torch.rand_like(val) * val * torch.tensor([[1.0, 4.0, 1.0]], device=device)
+        )
+
+        # nb
+        i = torch.arange(val.size(0), device=device)
+        j = val.argmax(1)
+        snake_direction = snake_next_direction[i, j]
+
+        sequences[:, 2 * l] = worlds[count, snake_position[:, 0], snake_position[:, 1]]
+        sequences[:, 2 * l + 1] = snake_direction
+
+        # nb x 2
+        snake_position = snake_next_position[i, j]
+
+    return sequences, worlds
+
+    # print(snake_position)
+
+
+# generate_snake_sequences(nb=1, height=4, width=6, nb_colors=3, length=20)
+# exit(0)
+
+
+class TaskSnake(Task):
+    def __init__(
+        self,
+        nb_train_samples,
+        nb_test_samples,
+        batch_size,
+        height,
+        width,
+        nb_colors,
+        length,
+        device=torch.device("cpu"),
+    ):
+        self.batch_size = batch_size
+        self.height = height
+        self.width = width
+        self.device = device
+
+        self.train_input, self.train_worlds = generate_snake_sequences(
+            nb_train_samples, height, width, nb_colors, length, self.device
+        )
+        self.test_input, self.test_worlds = generate_snake_sequences(
+            nb_test_samples, height, width, nb_colors, length, self.device
+        )
+
+        self.nb_codes = max(self.train_input.max(), self.test_input.max()) + 1
+
+    def batches(self, split="train", nb_to_use=-1, desc=None):
+        assert split in {"train", "test"}
+        input = self.train_input if split == "train" else self.test_input
+        if nb_to_use > 0:
+            input = input[:nb_to_use]
+        if desc is None:
+            desc = f"epoch-{split}"
+        for batch in tqdm.tqdm(
+            input.split(self.batch_size), dynamic_ncols=True, desc=desc
+        ):
+            yield batch
+
+    def vocabulary_size(self):
+        return self.nb_codes
+
+
+######################################################################
+
+
+def picoclvr_pruner_horizontal_green(p):
     return not ("green" in p and ("left" in p or "right" in p))
 
 
-task = TaskPicoCLVR(
-    batch_size=args.batch_size,
-    height=args.height,
-    width=args.width,
-    nb_colors=args.nb_colors,
-    device=device,
-    pruner_train=pruner_horizontal_green
-    if args.prune_properties in {"train+eval"}
-    else None,
-    pruner_eval=(lambda p: not pruner_horizontal_green(p))
-    if args.prune_properties in {"train+eval", "eval"}
-    else None,
+picoclvr_pruner_train = (
+    picoclvr_pruner_horizontal_green
+    if args.picocvlr_prune_properties in {"train+eval"}
+    else None
 )
 
+picoclvr_pruner_eval = (
+    (lambda p: not picoclvr_pruner_horizontal_green(p))
+    if args.picocvlr_prune_properties in {"train+eval", "eval"}
+    else None
+)
+
+######################################################################
+
+if args.task == "picoclvr":
+    task = TaskPicoCLVR(
+        nb_train_samples=args.nb_train_samples,
+        nb_test_samples=args.nb_test_samples,
+        batch_size=args.batch_size,
+        height=args.picoclvr_height,
+        width=args.picoclvr_width,
+        nb_colors=args.picoclvr_nb_colors,
+        device=device,
+        pruner_train=picoclvr_pruner_train,
+        pruner_eval=picoclvr_pruner_eval,
+    )
+
+elif args.task == "mnist":
+    task = TaskMNIST(
+        batch_size=args.batch_size,
+        device=device,
+    )
+
+elif args.task == "maze":
+    task = TaskMaze(
+        nb_train_samples=args.nb_train_samples,
+        nb_test_samples=args.nb_test_samples,
+        batch_size=args.batch_size,
+        height=args.maze_height,
+        width=args.maze_width,
+        nb_walls=args.maze_nb_walls,
+        device=device,
+    )
+
+elif args.task == "snake":
+    task = TaskSnake(
+        nb_train_samples=args.nb_train_samples,
+        nb_test_samples=args.nb_test_samples,
+        batch_size=args.batch_size,
+        height=args.snake_height,
+        width=args.snake_width,
+        nb_colors=args.snake_nb_colors,
+        length=args.snake_length,
+        device=device,
+    )
+
+else:
+    raise ValueError(f"Unknown task {args.task}")
+
+######################################################################
+
+log_string(f"device {device}")
+
 vocabulary_size = task.vocabulary_size()
 
 log_string(f"vocabulary_size {vocabulary_size}")
@@ -561,7 +906,6 @@ if nb_epochs_finished >= nb_epochs:
     task.produce_results(nb_epochs_finished, model)
 
 for n_epoch in range(nb_epochs_finished, nb_epochs):
-
     learning_rate = learning_rate_schedule[n_epoch]
 
     log_string(f"learning_rate {learning_rate}")
@@ -592,7 +936,6 @@ for n_epoch in range(nb_epochs_finished, nb_epochs):
         optimizer.step()
 
     with torch.autograd.no_grad():
-
         model.eval()
 
         nb_test_samples, acc_test_loss = 0, 0.0