exploration d'hypothèse: on interprète la séquence des charactères à compresser
 comme une aire. le but c'est d'enlever la plus grande aire en utilisant le plus petit périmètre.
 notre périmètre consiste à être la longeur de la sous-séquence et sa fréquence. si les deux longeurs 
 avaient un poids égal, on chercherait simplement à trouver le plus grand carré (ou la forme la plus proche de).
 J'ai essayé avec des avec des poids égaux, et ça n'a pas fonctionné. J'ai ensuite décidé de préserver l'égalité des poids,
 mais sous un logarithme, càd log(longeur). Pour certains petits exemples, cette piste démontrait des résultats prometteurs,
 mais sur des textes plus difficiles et long les résultats n'étaient plus prometteurs. 
 La même chose s'est passé pour les poids sous une racine carré. 
 J'ai ensuite essayé d'ajuster l'algorithme afin de voir si la sous-séquence ayant la plus courte représentation compressive,
 (càd son entropie multiplié par son occurrence additionné par sa longeur multiplié par le nombre de charactères uniques) donnait
 des résultats plus intéressants. Pour la plupart des textes courts, j'avais pas mal les mêmes résultats qu'une compression huffman.
 L'agorithme fonctionne en genre O(n^4), donc ça crash sur des petits textes.
 le problème est qu'on ne peut pas utiliser une approche top-down pour la représentation que je souhaite faire.
 je compare mon algorithme avec celui du codage huffman. 

exploration 2e hypothèse: TODO dynamic programming

organisation des fichiers du projet concret

commence l'hypothèse d'une nouvelle méthode de compression: 
 c'est un type de merge par entropie. les détails sont à paufiner,
 mais le gros est de combiner deux charactères avec le plus petit entropie.
 essentiellement, le but c'est de combiner des charactères qui apparaissent souvent 
 ensemble pour former des nouveaux 'charactères' qui ont l'air d'être iid

 travail sur l'implémentation des algorithmes de compression classiques

 j'essaie de trouver une façon d'explorer la dérivée de la longeur de compression de chiffres représentés par nncr.
  ma première idée consiste à utiliser la formule de Newton-Gregory pour approximer la dérivée df(C(0)) = f(C(1)) - f(C(0)).

à cause des problèmes d'importation avec les modules de python, j'ai dû faire une petite réorganisation du projet. calisse

je commence à tester la représentation des chiffres naturels. je vérifie la distance entre chaque chiffre adjacent. il n'y a pas tant de lissage entre les chiffres
 il faudrait que je teste autre chose...

les résultats des distances des nombres naturels sont bruités et intéressants. la distance entre chiffres semble être plus lointaine le plus proche que les chiffres
 sont à eux. à interpréter... j'aimerai voir si le bruitage des "dérivées" peuvent être utile comme le bruit stochastique dans la descente de gradient. à voir

je recontinue le développement sur l'algorithme de charactère ancètres pour voir si je peux créer un algorithme de compression plus efficace.

je rencontre des bogues dans dgc, notamment la façon dont j'ai implmenté les noms des variables qui ont été fucking floues. j'ai réfactorisé les noms de variables
 afin de mieux comprendre ce qui se passe dans mon code. j'ai refactorisé l'algorithme et sa version simplifiée initiale fonctionne.

il faut que je commence la comparaison des modèles d'apprentissage machine. je commence à implémenter les benchmarks. mon premier modèle sera un modèle simple 
 de classification qui calculera la distance entre le "langage" d'une classe et un point à prédire.

j'ai converti deux jeux de données pour la compatibilité avec la compression, le jeu de données breast_cancer utilise une grande précision, donc je ne vais pas le convertir
 pour l'instant

j'ai effectué du travail refactorisant le code pour une meilleure réutilisabilité. lzw a été implémentée (et partiellement testée) dans le contexte de son besoin.

j'expérimente avec de nouvelles 'distances' de compression pour explorer la fonction de représentation numérique. je me rend compte que la représentation nncr
 n'est pas idéale. tout veut se converger vers 0. ce qui fait intuitivement u sens, la multiplication de 1 est plus basse le plus bas notre chiffre. ceci fait
 qu'avec notre compression, il y a moins d'information à compresser avec des valeurs plus petites. je vais essayer une représentation 'progress bar' pour voir si la
 représentation résoud le problème de convergence vers 0.

avec une fonction de compression lz78 qui calcule le pire cas en "représentation nncr", je valide mon observation précédente que tout veut se converger vers 0
 avec une représentation nncr.

Alors, avec les tailles toutes seules (nncr). on ne peut pas sortir de l'information utile en représentant les chiffres seuls comme des longeurs pire cas ou de
 répétitions du même charactère. pour une utilisation paramétrée. on peut potentiellement l'utiliser comme fonction de perte (vu la convergence vers 0), mais la
 complexité de sortir les informations dérivées de chaque paramètre risque d'excéder une difficulté utile pour notre cas d'apprentissage machine.

idée finale: il faut utiliser les algorithmes de compression dans le but de la vision initiale. la vision initiale impliquait le rasoir d'ockham. j'ai besoin
 d'une technique qui réduit le plus possible les paramètres d'un modèle. les modèles non-paramétrés sont cool, mais ont besoin des données pour classifier/régresser.
 Je propose un modèle (une version rudimentaire) qui paramétrise tout les éléments du dictionnaire de compression et garde comme valeur le compte de chaque élément du 
 dictionnaire. déjà par intuition, l'algorithme lzw aura de la difficulté à compresser (avec représentation nncr) les données de manière cohérente (potentiellement faire du surapprentissage).
 aussi, avec peu de données, le nombre de paramètres du dictionnaire risque d'être beaucoup plus que le nombre de paramètres initial. la transformation de données ne prends pas en compte 
 l'ordonnance des éléments du dictionnaire dans la compression, ce qui risque de perdre de l'information utile.
en gros, ce n'est pas une nouvelle opération d'apprentissage machine, mais plutôt une transformation des données par les algorithmes de compression. cette transformation permettra d'utiliser
 tous les algorithmes d'apprentissage machine déjà existants, simplifiant l'implémentation (en théorie si tout fonctionne).

il est maintenant temps d'implémenter ceci. je vais implémenter une transformation de données en nncr pour voir si la régression fonctionne.

je me rends compte que l'architecture que je crée est similaire à BoW.

pour l'instant, la conversion semble fonctionner. par contre, il faut introduire des tolérances pour que le script ne prenne pas toujours pour finir

todo absolute reduction (allowing for negative numbers in BoW), n^n 

that's all folks