X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=grids.py;h=47e586119fc052ebd6404ff8046942e4bafee196;hb=9ec709a2a08eb82dfc17ef1e24aa9a84751d63e0;hp=03da16d93c46a713fe0b7f382b2407d4c5470c52;hpb=e0ab20005e2578edff27d4246c6904cf1047ed22;p=culture.git diff --git a/grids.py b/grids.py index 03da16d..47e5861 100755 --- a/grids.py +++ b/grids.py @@ -74,6 +74,7 @@ class Grids(problem.Problem): predicted_prompts=None, predicted_answers=None, nrow=4, + margin=8, ): S = self.height * self.width As = prompts[:, 0 * (S + 1) : 0 * (S + 1) + S].view(-1, self.height, self.width) @@ -120,8 +121,6 @@ class Grids(problem.Problem): return y - margin = 8 - img_prompts = torch.cat( [ add_frame( @@ -195,10 +194,39 @@ class Grids(problem.Problem): def nb_token_values(self): return len(self.colors) + # @torch.compile + def rec_coo_(self, nb_rec, min_height=3, min_width=3): + # @torch.compile + def overlap(ia, ja, ib, jb): + return ( + ia[1] >= ib[0] and ia[0] <= ib[1] and ja[1] >= jb[0] and ja[0] <= jb[1] + ) + + if nb_rec == 3: + while True: + i = torch.randint(self.height + 1, (nb_rec, 2)).sort(dim=1).values + j = torch.randint(self.width + 1, (nb_rec, 2)).sort(dim=1).values + if ( + not ( + overlap(i[0], j[0], i[1], j[1]) + or overlap(i[0], j[0], i[2], j[2]) + or overlap(i[1], j[1], i[2], j[2]) + ) + and (i[:, 1] - i[:, 0]).min() >= min_height + and (j[:, 1] - j[:, 0]).min() >= min_width + ): + break + return ( + (i[0, 0], j[0, 0], i[0, 1], j[0, 1]), + (i[1, 0], j[1, 0], i[1, 1], j[1, 1]), + (i[2, 0], j[2, 0], i[2, 1], j[2, 1]), + ) + # That's quite a tensorial spaghetti mess to sample # non-overlapping rectangles quickly, but made the generation of # 100k samples go from 1h50 with a lame pure python code to 3min30s # with this one. + # @torch.compile def rec_coo(self, nb_rec, min_height=3, min_width=3): nb_trials = 200 @@ -260,6 +288,7 @@ class Grids(problem.Problem): ) ] + # @torch.compile def rec_coo_(self, x, n, min_height=3, min_width=3): collision = x.new(x.size()) while True: @@ -284,6 +313,7 @@ class Grids(problem.Problem): ###################################################################### + # @torch.compile def task_replace_color(self, A, f_A, B, f_B): nb_rec = 3 c = torch.randperm(len(self.colors) - 1)[: nb_rec + 1] + 1 @@ -294,6 +324,7 @@ class Grids(problem.Problem): X[i1:i2, j1:j2] = c[n] f_X[i1:i2, j1:j2] = c[n if n > 0 else -1] + # @torch.compile def task_translate(self, A, f_A, B, f_B): di, dj = torch.randint(3, (2,)) - 1 nb_rec = 3 @@ -318,6 +349,7 @@ class Grids(problem.Problem): else: f_X[i1:i2, j1:j2] = c[n] + # @torch.compile def task_grow(self, A, f_A, B, f_B): di, dj = torch.randint(2, (2,)) * 2 - 1 nb_rec = 3 @@ -343,6 +375,7 @@ class Grids(problem.Problem): X[i1:i2, j1:j2] = c[n] f_X[i1:i2, j1:j2] = c[n] + # @torch.compile def task_color_grow(self, A, f_A, B, f_B): di, dj = torch.randint(2, (2,)) * 2 - 1 nb_rec = 3 @@ -384,6 +417,7 @@ class Grids(problem.Problem): else: f_X[i1:i2, j : j + 1] = c[2 * n + 1] + # @torch.compile def task_frame(self, A, f_A, B, f_B): nb_rec = 3 c = torch.randperm(len(self.colors) - 1)[: nb_rec + 1] + 1 @@ -396,6 +430,7 @@ class Grids(problem.Problem): if n == nb_rec - 1: f_X[i1 + 1 : i2 - 1, j1 + 1 : j2 - 1] = 0 + # @torch.compile def task_detect(self, A, f_A, B, f_B): nb_rec = 3 c = torch.randperm(len(self.colors) - 1)[: nb_rec + 1] + 1 @@ -407,6 +442,7 @@ class Grids(problem.Problem): if n < nb_rec - 1: f_X[i1, j1] = c[-1] + # @torch.compile def contact(self, X, i, j, q): nq, nq_diag = 0, 0 no = 0 @@ -442,8 +478,9 @@ class Grids(problem.Problem): return no, nq, nq_diag + # @torch.compile def task_count(self, A, f_A, B, f_B): - N = torch.randint(4, (1,)) + 2 + N = (torch.randint(4, (1,)) + 2).item() c = torch.randperm(len(self.colors) - 1)[:N] + 1 for X, f_X in [(A, f_A), (B, f_B)]: @@ -465,6 +502,7 @@ class Grids(problem.Problem): for j in range(nb[n]): f_X[n, j] = c[n] + # @torch.compile def task_trajectory(self, A, f_A, B, f_B): c = torch.randperm(len(self.colors) - 1)[:2] + 1 for X, f_X in [(A, f_A), (B, f_B)]: @@ -492,10 +530,11 @@ class Grids(problem.Problem): f_X[i + k * di, j + k * dj] = c[min(k, 1)] k += 1 + # @torch.compile def task_bounce(self, A, f_A, B, f_B): c = torch.randperm(len(self.colors) - 1)[:3] + 1 for X, f_X in [(A, f_A), (B, f_B)]: - + # @torch.compile def free(i, j): return ( i >= 0 @@ -555,6 +594,7 @@ class Grids(problem.Problem): if l > 3: break + # @torch.compile def task_scale(self, A, f_A, B, f_B): c = torch.randperm(len(self.colors) - 1)[:2] + 1 @@ -579,40 +619,109 @@ class Grids(problem.Problem): X[i, j] = c[1] f_X[0:2, 0:2] = c[1] - def task_islands(self, A, f_A, B, f_B): + # @torch.compile + def task_symbols(self, A, f_A, B, f_B): + nb_rec = 4 + c = torch.randperm(len(self.colors) - 1)[: nb_rec + 1] + 1 + delta = 3 for X, f_X in [(A, f_A), (B, f_B)]: - nb_on_border = 0 - for _ in range(10): - for k in torch.randperm(self.height * self.width): - i, j = k % self.height, k // self.height - border = ( - i == 0 or i == self.height - 1 or j == 0 or j == self.width - 1 - ) - no, nq, nq_diag = self.contact(X, i, j, 1) + while True: + i, j = torch.randint(self.height - delta + 1, (nb_rec,)), torch.randint( + self.width - delta + 1, (nb_rec,) + ) + d = (i[None, :] - i[:, None]).abs().max((j[None, :] - j[:, None]).abs()) + d.fill_diagonal_(delta + 1) + if d.min() > delta: + break + + for k in range(1, nb_rec): + X[i[k] : i[k] + delta, j[k] : j[k] + delta] = c[k] + + ai, aj = i.float().mean(), j.float().mean() + + q = torch.randint(3, (1,)) + 1 + + X[i[0] + delta // 2 - 1, j[0] + delta // 2 - 1] = c[0] + X[i[0] + delta // 2 - 1, j[0] + delta // 2 + 1] = c[0] + X[i[0] + delta // 2 + 1, j[0] + delta // 2 - 1] = c[0] + X[i[0] + delta // 2 + 1, j[0] + delta // 2 + 1] = c[0] - if ( - (nq > 0 and not border) - or (nq == 0 and border and nb_on_border < 4) - ) and nq_diag == 0: - X[i, j] = 1 - if border: - nb_on_border += 1 + assert i[q] != ai and j[q] != aj + X[ + i[0] + delta // 2 + (i[q] - ai).sign().long(), + j[0] + delta // 2 + (j[q] - aj).sign().long(), + ] = c[nb_rec] + + f_X[i[0] : i[0] + delta, j[0] : j[0] + delta] = c[q] + + # @torch.compile + def task_ortho(self, A, f_A, B, f_B): + nb_rec = 3 + di, dj = torch.randint(3, (2,)) - 1 + o = torch.tensor([[0.0, 1.0], [-1.0, 0.0]]) + m = torch.eye(2) + for _ in range(torch.randint(4, (1,))): + m = m @ o + if torch.rand(1) < 0.5: + m[0, :] = -m[0, :] + + ci, cj = (self.height - 1) / 2, (self.width - 1) / 2 + + for X, f_X in [(A, f_A), (B, f_B)]: while True: - nb_fixes = 0 - for i in range(1, self.height - 1): - for j in range(1, self.width - 1): + X[...] = 0 + f_X[...] = 0 + + c = torch.randperm(len(self.colors) - 1)[:nb_rec] + 1 + + for r in range(nb_rec): + while True: + i1, i2 = torch.randint(self.height - 2, (2,)) + 1 + j1, j2 = torch.randint(self.width - 2, (2,)) + 1 if ( - X[i, j] == 1 - and X[i - 1, j] + X[i + 1, j] + X[i, j - 1] + X[i, j + 1] - == 1 + i2 >= i1 + and j2 >= j1 + and max(i2 - i1, j2 - j1) >= 2 + and min(i2 - i1, j2 - j1) <= 3 ): - X[i, j] = 0 - nb_fixes += 1 + break + X[i1 : i2 + 1, j1 : j2 + 1] = c[r] + + i1, j1, i2, j2 = i1 - ci, j1 - cj, i2 - ci, j2 - cj + + i1, j1 = m[0, 0] * i1 + m[0, 1] * j1, m[1, 0] * i1 + m[1, 1] * j1 + i2, j2 = m[0, 0] * i2 + m[0, 1] * j2, m[1, 0] * i2 + m[1, 1] * j2 + + i1, j1, i2, j2 = i1 + ci, j1 + cj, i2 + ci, j2 + cj + i1, i2 = i1.long() + di, i2.long() + di + j1, j2 = j1.long() + dj, j2.long() + dj + if i1 > i2: + i1, i2 = i2, i1 + if j1 > j2: + j1, j2 = j2, j1 - if nb_fixes == 0: + f_X[i1 : i2 + 1, j1 : j2 + 1] = c[r] + + n = F.one_hot(X.flatten()).sum(dim=0)[1:] + if ( + n.sum() > self.height * self.width // 4 + and (n > 0).long().sum() == nb_rec + ): break + # @torch.compile + def task_islands(self, A, f_A, B, f_B): + pass + + # for X, f_X in [(A, f_A), (B, f_B)]: + # n = torch.arange(self.height * self.width).reshape(self.height, self.width) + # k = torch.randperm(self.height * self.width) + # X[...]=-1 + # for q in k: + # i,j=q%self.height,q//self.height + # if + ###################################################################### def all_tasks(self): @@ -627,10 +736,20 @@ class Grids(problem.Problem): self.task_trajectory, self.task_bounce, self.task_scale, + self.task_symbols, + self.task_ortho, # self.task_islands, ] - def generate_prompts_and_answers(self, nb, tasks=None, device="cpu"): + def trivial_prompts_and_answers(self, prompts, answers): + S = self.height * self.width + Bs = prompts[:, 2 * (S + 1) : 2 * (S + 1) + S] + f_Bs = answers + return (Bs == f_Bs).long().min(dim=-1).values > 0 + + def generate_prompts_and_answers( + self, nb, tasks=None, progress_bar=False, device="cpu" + ): if tasks is None: tasks = self.all_tasks() @@ -638,12 +757,17 @@ class Grids(problem.Problem): prompts = torch.zeros(nb, 3 * S + 2, dtype=torch.int64) answers = torch.zeros(nb, S, dtype=torch.int64) - for prompt, answer in tqdm.tqdm( - zip(prompts, answers), - dynamic_ncols=True, - desc="world generation", - total=prompts.size(0), - ): + bunch = zip(prompts, answers) + + if progress_bar: + bunch = tqdm.tqdm( + bunch, + dynamic_ncols=True, + desc="world generation", + total=prompts.size(0), + ) + + for prompt, answer in bunch: A = prompt[0 * (S + 1) : 0 * (S + 1) + S].view(self.height, self.width) f_A = prompt[1 * (S + 1) : 1 * (S + 1) + S].view(self.height, self.width) B = prompt[2 * (S + 1) : 2 * (S + 1) + S].view(self.height, self.width) @@ -679,24 +803,39 @@ class Grids(problem.Problem): if __name__ == "__main__": import time - nb = 48 - grids = Grids() - # for t in grids.all_tasks(): - for t in [grids.task_islands]: - print(t.__name__) - prompts, answers = grids.generate_prompts_and_answers(nb, tasks=[t]) - grids.save_quizzes("/tmp", t.__name__, prompts[:nb], answers[:nb], nrow=4) + # nb = 1000 + # grids = problem.MultiThreadProblem( + # grids, max_nb_cached_chunks=50, chunk_size=100, nb_threads=1 + # ) + # time.sleep(10) + # start_time = time.perf_counter() + # prompts, answers = grids.generate_prompts_and_answers(nb) + # delay = time.perf_counter() - start_time + # print(f"{prompts.size(0)/delay:02f} seq/s") + # exit(0) - exit(0) + if True: + nb = 72 + + for t in grids.all_tasks(): + # for t in [grids.task_ortho]: + print(t.__name__) + prompts, answers = grids.generate_prompts_and_answers(nb, tasks=[t]) + grids.save_quizzes("/tmp", t.__name__, prompts[:nb], answers[:nb], nrow=4) + + exit(0) - nb = 72 + nb = 500 - start_time = time.perf_counter() - prompts, answers = grids.generate_prompts_and_answers(nb) - delay = time.perf_counter() - start_time - print(f"{prompts.size(0)/delay:02f} seq/s") + for t in grids.all_tasks(): + start_time = time.perf_counter() + prompts, answers = grids.generate_prompts_and_answers(nb, tasks=[t]) + delay = time.perf_counter() - start_time + print(f"{t.__name__} {prompts.size(0)/delay:02f} seq/s") + + exit(0) m = torch.randint(2, (prompts.size(0),)) predicted_prompts = m * (torch.randint(2, (prompts.size(0),)) * 2 - 1)