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=400)
+
######################################################################
args = parser.parse_args()
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")
+ image_name = os.path.join(args.result_dir, f"mnist_result_{n_epoch:04d}.png")
torchvision.utils.save_image(
1 - results.reshape(-1, 1, 28, 28) / 255.0,
image_name,
mazes, paths = self.seq2map(input)
_, predicted_paths = self.seq2map(result)
- filename = os.path.join(args.result_dir, f"result_{n_epoch:04d}.png")
+ filename = os.path.join(args.result_dir, f"maze_result_{n_epoch:04d}.png")
maze.save_image(
filename,
mazes=mazes,
def generate_snake_sequences(
nb, height, width, nb_colors, length, device=torch.device("cpu")
):
- world = torch.randint(nb_colors, (nb, height, width), device=device)
+ worlds = torch.randint(nb_colors, (nb, height, width), device=device)
# nb x 2
snake_position = torch.cat(
(
),
1,
)
- snake_direction = torch.randint(4, (nb, 1), device=device)
- result = torch.empty(nb, 2*length, device=device, dtype=torch.int64)
- count = torch.arange(nb, device=device) # [:,None]
+ snake_direction = torch.randint(4, (nb,), device=device)
+ sequences = torch.empty(nb, 2 * length, device=device, dtype=torch.int64)
+ i = torch.arange(nb, device=device) # [:,None]
for l in range(length):
# nb x 3
snake_next_direction = torch.cat(
(
- (snake_direction - 1) % 4,
- snake_direction,
- (snake_direction + 1) % 4,
+ (snake_direction[:, None] - 1) % 4,
+ snake_direction[:, None],
+ (snake_direction[:, None] + 1) % 4,
),
1,
)
snake_next_position[:, :, 1] >= 0, snake_next_position[:, :, 1] < width
),
).float()
- val = torch.rand_like(val) * val * torch.tensor([[1.,4.,1.]], device=device)
+ 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]
- # nb x 1
- snake_direction = snake_next_direction[i[:, None], j[:, None]]
-
- result[:, 2*l] = world[count, snake_position[:, 0], snake_position[:, 1]]
- result[:, 2*l+1] = snake_direction[:,0]
+ sequences[:, 2 * l] = worlds[i, snake_position[:, 0], snake_position[:, 1]] + 4
+ sequences[:, 2 * l + 1] = snake_direction
# nb x 2
- snake_position = snake_next_position[i[:, None], j[:, None]].squeeze(1)
+ snake_position = snake_next_position[i, j]
+
+ return sequences, worlds
- return result
-generate_snake_sequences(nb=2, height=4, width=5, nb_colors=3, length=10)
-exit(0)
+# generate_snake_sequences(nb=1, height=4, width=6, nb_colors=3, length=20)
+# exit(0)
+
class TaskSnake(Task):
def __init__(
self.width = width
self.device = device
- self.train_input = generate_snake_sequences(
+ self.train_input, self.train_worlds = generate_snake_sequences(
nb_train_samples, height, width, nb_colors, length, self.device
)
- self.test_input = generate_snake_sequences(
+ self.test_input, self.test_worlds = generate_snake_sequences(
nb_test_samples, height, width, nb_colors, length, self.device
)
def vocabulary_size(self):
return self.nb_codes
+ def produce_results(self, n_epoch, model):
+ with torch.autograd.no_grad():
+ t = model.training
+ model.eval()
+
+ def compute_nb_correct(input):
+ result = input.clone()
+ i = torch.arange(result.size(1), device=result.device)
+ ar_mask = torch.logical_and(i >= i.size(0) // 2, i % 2 == 0)[
+ None, :
+ ].long()
+ result *= 1 - ar_mask
+ masked_inplace_autoregression(
+ model, self.batch_size, result, ar_mask, device=self.device
+ )
+
+ nb_total = ar_mask.sum() * input.size(0)
+ nb_correct = ((result == input).long() * ar_mask).sum()
+
+ # nb_total = result.size(0)
+ # nb_correct = ((result - input).abs().sum(1) == 0).sum()
+
+ return nb_total, nb_correct
+
+ train_nb_total, train_nb_correct = compute_nb_correct(self.train_input)
+
+ 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 = compute_nb_correct(self.test_input)
+
+ 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}%"
+ )
+
+ model.train(t)
+
######################################################################
nb_train_samples=args.nb_train_samples,
nb_test_samples=args.nb_test_samples,
batch_size=args.batch_size,
- height=6,
- width=8,
- nb_colors=5,
- length=100,
+ height=args.snake_height,
+ width=args.snake_width,
+ nb_colors=args.snake_nb_colors,
+ length=args.snake_length,
device=device,
)