Readme.md

## metrics to track
- loss per epoch per model boost layer
- number of error per epoch model boost layer
- number of resolved puzzles per epochs
- threshold per epochs per model layer
- number of filled digits per model boost layer per epoch for both pis ans abs

## TODO
- jupyter notebook to python file
- threshold compute on test set (with adding a gap) each epoch. and training threshold initialised with test thresholds that evolve each error during training.

## Possible way
- it might be smart to store the intermitent states as boost layereds "buffers". at the end the first X go to the model layer 0 let write it as puseudo code

### Method threshold
```
global init
th ->  -10
training step
  init 
    pass
  training loop
    keep th behind the error limit
validation step
  init
    compute_th =-10
  validation loop
    keep compute_th behind error limit + marge
    but use th
  end
    th= compute_th
```

### Method training
```
Xs -> the x initial batch vector 
Y -> the y batch vector
Xs' = M0(Xs)
then we filter Xs'=Y -> resolved sudokus
Xs'==Xs -> we add the rows to X1 buffer
and the remaning Xs' is added to X0 buffer.
```

then we look at each buffers X0 to Xn and we process each of them that are => batch size.

When every buffer are smaller than batch size the process is finished.

object 
```
Buffers
get_batch(limit_batch_size=True) -> idx, Xb # Xb could be none. (Xb should be a shuffled sample of the batch)
add_batch(Xp, idx)
```


### Loss optimisation
Both 0 and 1 target are different in the way we should gradient descend them.
y==0 point is something easy: it should be as low as possible I thing we can use the usual log loss function on it.
y==1 is different: there is different case possible:
 - the point could be "unpredictable" in that case the gradient descend should be tuned to low, we expect the predictive function to have a low score.
 - the point could be well predicted in that case we hope the value is prety hight and we would like to the the gradient descend more heavely.
This could be applied by using a sigmoid centered on the threshold


### Paper writing

Les niveaux supérieurs font appel à divers types de chaînes :

11.6 Dynamic + Dynamic Forcing Chains (145-192 nodes) Cell Forcing Chains
11.7 Dynamic + Dynamic Forcing Chains (193-288 nodes) Double Forcing Chains
Ces Dynamic Forcing Chains sont une forme d’essais et erreurs.

### Trial and error solving technique
We applied trial and error solving technique to reach 100% accuracy over sudoku. The resoning is simple we find the best digit/position to test and produce 2 children grid one with the number the other without. the we process each grid until one of them break sudoku's rules .

The V1 of this algorithm should only stopped at 1 trail and error test (no binary tree search) it should be simpler and feasible and if not : we will se an improve and try the next step.