improving backtracking algorithm and display in the app

app.py

@@ -117,12 +117,19 @@ if n_sol==1:
         i+=1
         st.markdown(f'iteration {i}')
         try:
-            new_X = model.predict(new_X)
+            new_X = model.predict(new_X, func_text_display=st.markdown)
         except TrialEveryPosException:
             st.markdown('''## The grid is super evil!
             please share it as A Discussion in the `Community` tab.
-            Except if it is this one: https://www.telegraph.co.uk/news/science/science-news/9359579/Worlds-hardest-sudoku-can-you-crack-it.html''')
-            is_valid, new_X = model.backtracking_predict(new_X)
+            Except if it is this one: https://www.telegraph.co.uk/news/science/science-news/9359579/Worlds-hardest-sudoku-can-you-crack-it.html
+            
+            Using trail error model enhanced by backtracking
+            ''')
+            is_valid, new_X = model.backtracking_predict(
+                new_X,
+                func_text_display=st.markdown,
+                func_tensor_display=lambda t: st.html(display_as_dataframe(t).to_html(escape=False, index=False)),
+            )
             assert is_valid
         st.html(display_as_dataframe(new_X).to_html(escape=False, index=False))
         new_X_sum = new_X.sum()

sudoku/helper.py

@@ -157,4 +157,12 @@ def legal(row, col, num, grid):
     return True
 
 def get_grid_number_soluce(grid):
-    return solve(0,0,grid,0)
+    return solve(0,0,grid,0)
+
+
+def pos_to_digit_col_row(pos):
+    # pos = i+j*9+k*9*9
+    digit = pos%9+1
+    col = (pos//9)%9+1
+    row=pos//(9*9)+1
+    return digit, col, row

sudoku/train.py

@@ -8,6 +8,7 @@ import torch.nn.functional as F
 
 from sudoku.buffer import BufferArray, Buffer
 from sudoku.trial_grid import TrialGrid
+from sudoku.helper import pos_to_digit_col_row
 
 from copy import deepcopy
 
@@ -374,6 +375,8 @@ class SudokuLightning(pl.LightningModule):
             (self.sym_preprocess(x)[:, 17].max(dim=1).values > (1 / 8))
             | (self.sym_preprocess(x)[:, 18].max(dim=1).values > (1 / 8))
             | (self.sym_preprocess(x)[:, 19].max(dim=1).values > (1 / 8))
+            | (x.view(-1,2,9,9,9)[:,1].sum(dim=-1)>1).any(dim=1).any(dim=1)
+            | (x.view(-1,2,9,9,9)[:,0].sum(dim=-1)>8).any(dim=1).any(dim=1)
         )
 
     # steps to trial error
@@ -828,13 +831,15 @@ class SudokuTrialErrorLightning(SudokuLightning):
         self.log(f"{prefix}_y_pos_trial_error", y.sum())
         self.log(f"{prefix}_y_neg_trial_eror", y.shape[0]-y.sum())
 
-    def predict(self, x):
+    def predict(self, x, func_text_display=None):
         """ return an improvement of x
         
         """
         
         idx, new_X = self.forward(x.view(-1,2,729))
         if (new_X.sum()>x.sum()) or (new_X.sum()==729):
+            if func_text_display:
+                func_text_display(f'boost layer step: {idx}')
             return new_X
         else:
             # call trial error until we find a solution
@@ -854,34 +859,61 @@ class SudokuTrialErrorLightning(SudokuLightning):
                     mask_validated = self.validate_grids(new_X)
                     if mask_validated.sum()<2:
                         x[0, mask_validated, pos] = 1 # TODO check if it work
+                        if func_text_display:
+                            digit, col, row = pos_to_digit_col_row(pos)
+                            func_text_display('model failed to improve the grid')
+                            func_text_display(f'trial error alogorithm, found error at digit: {digit}, col: {col}, row: {row}')
                         return x
                     if X_tried.sum()==new_X.sum():
-                        # if both stop to improve -> break it will tried an new pos
+                            # if both stop to improve -> break it will tried an new pos
                         break
                     mask_complete = (X_tried.sum(dim=1)==729)# check if it works
                     if mask_complete.sum()>0:
                         x[0, mask_complete, pos] = 1
+                        if func_text_display:
+                            digit, col, row = pos_to_digit_col_row(pos)
+                            func_text_display('model failed to improve the grid')
+                            func_text_display(f'trial error alogorithm, complete the grid with digit: {digit}, col: {col}, row: {row}')
                         return x
                     X_tried = new_X
                     # if one of X_tried is complete (weird but possible) -> return x with tried_position mask_complet set to 1 (cause we still want a step by step resolution)
     
-    def backtracking_predict(self, x):
+    def backtracking_predict(self, x, use_trial_error=False, assumption=[], func_text_display=None, func_tensor_display=None):
         """
         return is_valid, new_x
         """
         next_X = deepcopy(x)
         sum_1 = next_X.sum().item()
-        while True:
-            idx, next_X = self.forward(next_X.view(1,2,729))
-            if not self.validate_grids(next_X)[0].item():
-                return False, None
-            sum_2 = next_X.sum().item()
-            if sum_1==sum_2:
-                break
-            else:
-                sum_1=sum_2
-        if next_X.sum()>=729:
-            return True, next_X
+        if use_trial_error:
+            while True:
+                try:
+                    next_X = self.predict(next_X.view(1,2,729))
+                    if not self.validate_grids(next_X)[0].item():
+                        if assumption is not []:
+                            func_text_display(f'assumption {assumption[-1]}, failed')
+                            func_text_display(f'assumption length {len(assumption)}')
+                            func_tensor_display(next_X)
+                            return False, None
+                    if next_X.sum()>=729:
+                        if assumption is not []:
+                            func_text_display(f'assumption length {len(assumption)}')
+                            func_tensor_display(next_X)
+                        return True, next_X
+                except TrialEveryPosException:
+                    break
+                
+        else:
+            while True:
+                _idx, next_X = self.forward(next_X.view(1,2,729))
+                if not self.validate_grids(next_X)[0].item():
+                    return False, None
+                sum_2 = next_X.sum().item()
+                if sum_1==sum_2:
+                    break
+                else:
+                    sum_1=sum_2
+            if next_X.sum()>=729:
+                return True, next_X
         
         pos = self.search_trial(next_X.view(2,729), [])
         new_x = deepcopy(next_X.view(1,2,729))
@@ -889,16 +921,25 @@ class SudokuTrialErrorLightning(SudokuLightning):
         pos_output = output[0,:,pos]
         if (pos_output[0].item()-self.threshold_abs[0].item())>(pos_output[1].item()-self.threshold_pres[0].item()):
             trial_abs_pres = 0
+            abs_pres_str = 'abs'
         else:
             trial_abs_pres = 1
+            abs_pres_str = 'pres'
         new_x[0,trial_abs_pres,pos]=1
-        print(f'assuming {(pos, pos%9, (pos//9)%9, pos//(9*9), trial_abs_pres)}')# i+j*9+n*9*9
-        is_valid, new_x = self.backtracking_predict(new_x)
+        # print(f'assuming {(pos, pos%9, (pos//9)%9, pos//(9*9), trial_abs_pres)}')# i+j*9+n*9*9
+        digit, col, row = pos_to_digit_col_row(pos)
+        func_text_display('grid not improving adding the assuption')
+        current_assumption = f'{abs_pres_str}, digit: {digit}, col: {col}, row: {row}'
+        func_text_display(current_assumption)
+        assumption.append(current_assumption)
+        is_valid, new_x = self.backtracking_predict(new_x, use_trial_error=use_trial_error, assumption=assumption, func_text_display=func_text_display, func_tensor_display=func_tensor_display)
         if not is_valid:
             new_x = deepcopy(next_X.view(1,2,729))
             new_x[0,(trial_abs_pres+1)%2,pos]=1
-            print(f'finally assuming {(pos, pos%9, (pos//9)%9, pos//(9*9), (trial_abs_pres+1)%2)}')# i+j*9+n*9*9
-            return self.backtracking_predict(new_x)
+            # print(f'finally assuming {(pos, pos%9, (pos//9)%9, pos//(9*9), (trial_abs_pres+1)%2)}')# i+j*9+n*9*9
+            current_assumption = f'{"pres" if abs_pres_str=="abs" else "abs"}, digit: {digit}, col: {col}, row: {row}'
+            func_text_display(current_assumption)
+            return self.backtracking_predict(new_x, use_trial_error=use_trial_error, assumption=assumption, func_text_display=func_text_display, func_tensor_display=func_tensor_display)
         return True, new_x