maj

Readme.md

@@ -17,31 +17,16 @@ Vous devez
 Ecrivez vos réponses et commentaires dans ce document.
 Puis décommenter `compare_taille` à la fin et expliquer les résultats.
 
-###Comparaison des tailles(compare_taille)
-*Résultats:
-#Courbes: 
-Le graphique montre l'évolution de la taille en mémoire de la table de hachage avec
-MPHF et du dictionnaire en fonction du nombre de k-mers(n)
-
-###Interpretation:
-#Table avec MPHF: 
-La taille de la table de hachage avec MPHF augmente linéairement avec n, mais 
-avec une pente plus faible que celle du dictionnaire. Cela est du à l'effcacité de la MPHF qui 
-minimise les collisions et donc la taille de la table.
-
-#Dict: 
-La taille du dictionnaire augmente également linéairement avec n, mais avec une pente elevée.
-Cela est du à la surcharge mémoire associée à la gestion des collisions et à la structure de données
-plus complexe
-
-#Efficacité: 
-La table de hachage avec MPHF est plus efficace en termes de mémoire que le dictionnaire
-standard, surtout pour de grands ensembles de données. Cela est du à la minimisation des collisions
-et à la structure plus compacte de la MPHF.
-
-#Utilisation: 
-Cette méthode est particulièrement utile dans des applications où la mémoire est une ressource
-critique, comme dans le traitement de grands ensembles de données génomiques.###
+###Explication des courble sur l'image  obtenu apres execution du code:
+Sur le graphique, on compare la mémoire utilisée par deux structures : une table de hachage construite avec une MPHF (en bleu) et un dictionnaire Python classique (en orange), en fonction du nombre de k-mers qu’on y stocke.
+
+La table avec MPHF :
+La courbe monte doucement et de façon régulière. Cela montre que la MPHF utilise la mémoire de manière très efficace : elle n’alloue que ce qui est strictement nécessaire. Elle ne laisse pas d’espace vide inutile et reste donc très compacte, ce qui est parfait quand on connaît à l’avance tous les k-mers qu’on veut stocker.
+
+Le dictionnaire :
+La courbe est beaucoup moins fluide. Elle monte par paliers, car le dictionnaire doit régulièrement agrandir sa structure interne pour pouvoir continuer à insérer des éléments. À chaque palier, il réserve plus d’espace que nécessaire, ce qui entraîne un gaspillage de mémoire. Et plus le nombre de k-mers augmente, plus ça devient lourd.
+ En résumé :
+La MPHF est clairement plus avantageuse en termes de mémoire, surtout quand on travaille avec de très grands ensembles de k-mers, comme c’est souvent le cas en bioinformatique. Le dictionnaire, lui, reste pratique et facile à utiliser, mais il devient vite inefficace quand on monte en volume.
 
 Bonus : faites varier `nb_niveaux` et `gamma`, voyez quelle influence ils peuvent avoir.
 

tp_2_miso_mphf.py

@@ -144,6 +144,7 @@ def create_hash_table(set_kmer, n):
     """
     # Créer la MPHF pour les k-mers
     mphf = construction_mphf(set_kmer, n)
+
     # Initialiser une table de taille n (liste de n cases)
     table = [None] * n
     # écrire les kmers aux adresses du tableau données par la mphf
@@ -183,6 +184,7 @@ def compare_taille(n_max, fichier_sortie):
 
         n_values.append(n)
         table_size.append(sys.getsizeof(tableau)+sys.getsizeof(mphf)) # pourquoi ici on ne mesure pas juste la taille en mémoire du tableau ?
+        #On ne mesure pas seulement la taille du tableau, car celui-ci contient uniquement les k-mers, mais pas la structure de la fonction de hachage minimale parfaite (MPHF) elle-même
         dict_size.append(sys.getsizeof(set_kmer))
 
     plt.plot(n_values, table_size, label='Table avec MPHF')
@@ -197,3 +199,5 @@ def compare_taille(n_max, fichier_sortie):
 
 # dé-commenter quand vous êtes prêts, expliquer les résultats
 compare_taille(10000,"mphf.png")
+
+