Skip to content
Snippets Groups Projects
Commit ae585d65 authored by Samuel Nguyen's avatar Samuel Nguyen
Browse files

Mise dans archive

parent 7005b64e
Branches main
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
README.md deleted 100644 → 0
+ 0
− 93
View file @ 7005b64e
# tp2_hachage
## Getting started
To make it easy for you to get started with GitLab, here's a list of recommended next steps.
Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
## Add your files
- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
```
cd existing_repo
git remote add origin https://gitlab.univ-lille.fr/samuel.nguyen.etu/tp2_hachage.git
git branch -M main
git push -uf origin main
```
## Integrate with your tools
- [ ] [Set up project integrations](https://gitlab.univ-lille.fr/samuel.nguyen.etu/tp2_hachage/-/settings/integrations)
## Collaborate with your team
- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
## Test and Deploy
Use the built-in continuous integration in GitLab.
- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
***
# Editing this README
When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
## Suggestions for a good README
Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
## Name
Choose a self-explaining name for your project.
## Description
Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
## Badges
On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
## Visuals
Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
## Installation
Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
## Usage
Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
## Support
Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
## Roadmap
If you have ideas for releases in the future, it is a good idea to list them in the README.
## Contributing
State if you are open to contributions and what your requirements are for accepting them.
For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
## Authors and acknowledgment
Show your appreciation to those who have contributed to the project.
## License
For open source projects, say how it is licensed.
## Project status
If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
Readme.md deleted 100644 → 0
+ 0
− 81
View file @ 7005b64e
# TP Hachage
# Partie 1 - Réaliser une fonction de hachage minimale parfaite
On travaillera sur `tp_2_miso_mphf.py`.
Tout d'abord, voyons ensemble l'idée de la construction de la MPHF.
Puis suivez les commentaires dans le code à compléter.
Vous devez
- finaliser la fonction pour construire la MPHF (`construction_mphf`),
- écrire la fonction pour obtenir le hash d'un élément par la MPHF (`get_hash_mphf`),
- écrire la fonction pour créer une table de hachage avec cette mphf (`create_hash_table`)
Ecrivez vos réponses et commentaires dans ce document.
Puis décommenter `compare_taille` à la fin et expliquer les résultats.
On observe sur le graphe obtenu, que la taille de la table de hachage du dictionnaire augmente par paliers, alors que celle de la MPHf augmente de manière linéraire, et beaucoupu plus progressivement.
Cela est cohérent, en effet le dictionnaire va allouer un certain espace supplémentaire dès que le nombre d'éléments atteint un seuil, d'où l'augmentation par paliers.
Quant à la MPHF, elle minimise la mémoire en évitant les collisions, et en recréant à chaque implémentation, une nouvelle table de hachage avec la taille exactement adaptée au nombre d'éléments.
Bonus : faites varier `nb_niveaux` et `gamma`, voyez quelle influence ils peuvent avoir.
# Partie 2 - Analyse de performance de dictionnaires en Python
On travaillera sur `tp_2_miso_dict.py`
A la fin de cette partie, en lançant `python tp_2_miso_dict.py` on doit obtenir 4 graphiques.
## Introduction
Nous allons analyser la performance de dictionnaires `dict` en Python en fonction de différents facteurs : que le facteur de charge (loading factor),
le temps d'insertion et la taille de la mémoire occupée. Vous pourrez utiliser matplotlib et numpy pour visualiser les résultats.
## Étude du facteur de charge
Fonction `experiment_load_factor`:
0. La fonction `experiment_load_factor` doit être définie pour prendre en entrée une liste de facteurs de charge (`load_factors`) et renvoyer les temps
- d'insertion de clefs,
- les nombres de réallocations de mémoire (quand le dictionnaire est ré-écrit en mémoire pour agrandir sa taille)
- et les tailles de mémoire occupées par le dictionnaire pour chaque facteur de charge.
1. Initialisation des listes pour stocker les résultats.
Initialiser dans la fonction `experiment_load_factor` des listes `insertion_times`, `num_resizes` et `sizes` seront utilisées pour stocker les trois résultats décrits au dessus.
2. La fonction `experiment_load_factor` doit boucler sur chaque facteur de charge de la liste en entrée `load_factors`. Créer un dictionnaire d'abord vide à chaque fois.
3. Initialiser les variables `num_elements`, `start_time`, `num_resize` et `last_size` pour respectivement mesurer le nombre d'éléments, le temps d'insertion et le nombre de réallocations de mémoire.
4. Insérer les éléments dans le dictionnaire et mesurer le temps d'insertion pour chaque élément, vérifier le nombre de réallocations mémoire (utiliser par exemple `time.time()` et `sys.getsizeof()` pour mesurer le temps et la taille du dictionnaire avant et après chaque insertion).
5. Pour un facteur de charge donné, stocker les résultats dans les listes `insertion_times`, `num_resizes` et `sizes`.
## Deuxième étude
6. A quoi sert la fonction `experiment_longest` ?
Cette fonction renvoie la fréquence des temps d'insertion dans un dictionnaire, sur 10 000 éléments à insérer.
## Visualisation des résultats
7. Créez quatre graphiques au format png ou pdf :
- Un graphique du temps d'insertion en fonction du facteur de charge (obtenu question 5)
- Un graphique du nombre de réallocations de mémoire en fonction du facteur de charge (obtenu question 5)
- Un graphique de la taille de mémoire occupée en fonction du nombre d'éléments (obtenu question 5)
- Un histogramme des fréquences des temps d'insertions discrétisés (code fourni, remplacer la liste vide par la bonne entrée)
10. Commentez vos résultats.
- Le nombre de réallocations de mémoire augmente en fonction du facteur de charge, d'abord linéairement puis plutôt par paliers.
Cela est cohérent avec le graphe généré partie 1, car le dictionnaire va allouer un certain espace supplémentaire dès que le nombre d'éléments atteint un seuil.
- En conséquence, la variation de la taille de mémoire occupée en fonction du nombre d'éléments suit la même variation, linéaire au début puis par paliers.
- Le temps d'insertion en fonction du facteur de charge diminue fortement lorsque le facteur de charge augmente au début, puis les variations sont plus faibles.
Cette tendance semble cohérente, hormis une réaugmentation à 0.6 : au début, le dictionnaire est vide, et l'ajout d'éléments est rapide. La réaugmentation est peut-être due à des réallocations de mémoire qui ralentissent certaines insertions.
- La distribution des temps d'insertion sur l'histogramme est très asymétrique : une majorité d'insertions se font très rapidement, tandis que quelques valeurs semblent avoir des temps d'insertion plus longs.
Cela s'explique peut-être par des réallocations de mémoire ponctuelles qui allongent le temps d'insertion à certains moments.
deuxieme_etude.png deleted 100644 → 0
+ 0
− 0
View file @ 7005b64e
deuxieme_etude.png

18 KiB

mphf.png deleted 100644 → 0
+ 0
− 0
View file @ 7005b64e
mphf.png

33.5 KiB

nombre_reallocations.png deleted 100644 → 0
+ 0
− 0
View file @ 7005b64e
nombre_reallocations.png

24.9 KiB

slides_hash.pdf deleted 100644 → 0
+ 0
− 0
View file @ 7005b64e
File deleted
taille_memoire.png deleted 100644 → 0
+ 0
− 0
View file @ 7005b64e
taille_memoire.png

27.6 KiB

temps_d_insertion.png deleted 100644 → 0
+ 0
− 0
View file @ 7005b64e
temps_d_insertion.png

25 KiB

tp2_miso.zip 0 → 100644
+ 0
− 0
View file @ ae585d65
File added
tp_2_miso_dict.py deleted 100644 → 0
+ 0
− 119
View file @ 7005b64e
import matplotlib.pyplot as plt
import numpy as np
import time
import sys
import statistics #pour faire la moyenne des temps d'insertion pour chaque facteur de charge
###### PARTIE 2 ######
def experiment_load_factor(load_factors : list):
"""
Étude du facteur de charge
Parameters
----------
load_factors : list
Une liste de facteurs de charge
Returns
-------
lists
Les temps d'insertion de clefs
Les nombres de réallocations de mémoire
Les tailles de mémoire occupée par le dictionnaire pour chaque facteur de charge
"""
# Initialisation
insertion_times = []
num_resizes = []
sizes = []
for factor in load_factors :
dictio = {}
num_resize=0
last_size = sys.getsizeof(dictio)
num_elements = int(factor*100)
tempsecoules = []
for i in range(num_elements) :
cle = 'cle'+str(i)
start_time = time.perf_counter()
dictio[cle] = i
end_time = time.perf_counter()
tempsecoule = end_time - start_time
tempsecoules.append(tempsecoule)
current_size = sys.getsizeof(dictio)
if current_size > last_size :
num_resize += 1
last_size = current_size
size = sys.getsizeof(dictio)
insertion_time = statistics.mean(tempsecoules)
insertion_times.append(insertion_time)
num_resizes.append(num_resize)
sizes.append(size)
return insertion_times, num_resizes, sizes
def experiment_longest():
"""
TODO: que fait cette fonction
"""
d = {}
insertion_times = []
for i in range(10000):
key = str(i)
value = i
start_time = time.time()
d[key] = value
insertion_time = time.time() - start_time
insertion_times.append(insertion_time)
frequencies = np.histogram(insertion_times)[0]
return frequencies
def visualisation(load_factors, insertion_times, num_resizes, sizes, frequencies):
"""
Visualisation des résultats
"""
num_elements = []
for factor in load_factors :
num_elements.append(factor*100)
# Temps d'insertion en fonction du facteur de charge
plt.plot(load_factors, insertion_times)
plt.xlabel('Facteur de charge')
plt.xticks(load_factors, [str(x) for x in load_factors], rotation=45)
plt.ylabel("Temps d'insertion (secondes)")
plt.title("Temps d'insertion en fonction du facteur de charge")
plt.savefig("temps_d_insertion.png")
# Nombre de réallocations de mémoire en fonction du facteur de charge
plt.plot(load_factors, num_resizes)
plt.xlabel('Facteur de charge')
plt.xticks(load_factors, [str(x) for x in load_factors], rotation=45)
plt.ylabel("Nombre de réallocations de mémoire")
plt.title("Nombre de réallocations de mémoire en fonction du facteur de charge")
plt.savefig("nombre_reallocations.png")
# Taille de mémoire occupée en fonction du nombre d'éléments
plt.plot(sizes, num_elements)
plt.xlabel("Nombre d'éléments")
plt.xticks(num_elements, [str(x) for x in num_elements], rotation=45)
plt.ylabel("Taille de mémoire occupée (octets)")
plt.title("Taille de mémoire occupée en fonction du nombre d'éléments")
plt.savefig("taille_memoire.png")
# Deuxième étude
f = list(frequencies)
plt.figure(figsize=(10, 6))
plt.bar(range(len(f)), f)
plt.xlabel('Temps d\'insertion (s)')
plt.ylabel('Fréquence')
plt.title('Histogramme des fréquences des temps d\'insertions')
plt.yscale('log')
xticks = np.logspace(-6, 1, 3)
xtick_labels = [f'{x:.1e}' for x in xticks]
plt.xticks(xticks, xtick_labels)
plt.savefig('deuxieme_etude.png')
load_factors = [0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
insertion_times, num_resizes, sizes = experiment_load_factor(load_factors)
frequencies = experiment_longest()
visualisation(load_factors, insertion_times, num_resizes, sizes, frequencies)
tp_2_miso_mphf.py deleted 100644 → 0
+ 0
− 210
View file @ 7005b64e
import matplotlib.pyplot as plt
import numpy as np
import time
import sys
import random
###### PARTIE 1 ######
def construction_mphf(set_kmer, n, gamma=2, nb_niveaux=3):
"""
Construit une fonction de hachage minimale parfaite (MPHF) pour un ensemble de k-mers.
Parameters:
set_kmer (set): Ensemble de k-mers.
n (int): Taille de l'ensemble de k-mers.
gamma (int): Facteur de réduction de la taille de la table de hachage. Default: 2.
nb_niveaux (int): Nombre de niveaux de réduction de la taille de la table de hachage. Default: 3.
Returns:
mphf (list): Table de hachage minimale parfaite.
Examples:
>>> set_kmer = {str(i) for i in range(10)}
>>> n = 10
>>> mphf = construction_mphf(set_kmer, n)
>>> len(mphf) == n
True
>>> all(0 <= mphf[i] < n for i in range(n))
True
>>> len(mphf) == n
True
"""
# Initialisation
set_kmer_courant = set_kmer.copy()
tableaux = []
collision = set()
for _ in range(nb_niveaux):
if len(set_kmer_courant) > 0:
l = len(set_kmer_courant)
if l == 0:
break # Evite une division par 0
tableau_principal = [-1] * (gamma * l)
for kmer in set_kmer_courant:
# hacher le k-mer (attention, hash() peut rendre des entiers signés, nous voulons des entiers positifs)
hachage = abs(hash(kmer))
# récupérer l'adresse
# si le tableau principal est déjà rempli à l'adresse:
# mettre le kmer dans collision()
# sinon, écrire le hash à l'adresse dans le tableau principal
adresse = hachage % (gamma * l)
if tableau_principal[adresse] != -1:
collision.add(kmer)
else:
tableau_principal[adresse] = hachage
tableaux.append(tableau_principal) # expliquer
# Chaque niveau de hachage produit un nouveau tableau de hachage.
# Donc on enregistre le tableau dans tableaux pour garder une trace des niveaux.
set_kmer_courant = collision.copy() # expliquer
# On hache à nouveau les k-mers qui ont causé des collisions.
collision = set() # expliquer
# On réinitialise collision pour le prochain niveau de hachage, pour pas que les valeurs dont on n'a plus besoin s'accumulent.
if not set_kmer_courant: # Arrête la boucle si plus de collisions
break
# Construction de la MPHF
mphf = []
grand_tableau = []
for tableau in tableaux:
grand_tableau.extend(tableau) # expliquer
# Après avoir fait tous les hachages, on regroupe les tableaux finaux de hachage dans un seul tableau.
grand_tableau_dict = {val: i for i, val in enumerate(grand_tableau)}
max_rang = 0
i = 0
for kmer in set_kmer:
# hacher le kmer
hache = abs(hash(kmer))
# si le hash est dans le grand_tableau
# récupérer son index
# récupérer son rang (utiliser la fonction count())
# ajouter à la mphf [h, rang]
# mettre à jour max_rang
if hache in grand_tableau_dict:
index = grand_tableau_dict[hache]
rang = grand_tableau[:index].count(hache)
mphf.append([hache, rang])
max_rang = max(max_rang, rang)
for kmer in set_kmer_courant: # gestion des collisions: expliquer les 3 lignes du dessous
max_rang += 1 # On attribue un nouveau rang unique à chaque élément en collision.
h = abs(hash(kmer)) # Recalcul du hash, on veut uniquement des entiers positifs.
mphf.append([h, max_rang]) # On ajoute le k-mer à mphf
# On fait ces étapes car les collisions n'ont pas pu être placées avant,
# on leur attribue un rang plus grand pour ne pas perturber l'ordre précédent
if not mphf:
print("Attention : MPHF vide, vérifiez les données en entrée.")
return mphf
def get_hash_mphf(mphf, kmer):
"""
Calcule le hash d'un k-mer à l'aide d'une fonction de hachage minimale parfaite (MPHF).
Parameters:
mphf (list): Table de hachage minimale parfaite.
kmer (str): K-mer à hasher.
Returns:
int: Hash du k-mer.
Examples:
>>> set_kmer = {str(i) for i in range(10)}
>>> n = 10
>>> mphf = construction_mphf(set_kmer, n)
>>> kmer = "5"
>>> hash_mphf = get_hash_mphf(mphf, kmer)
>>> 0 <= hash_mphf < n
True
"""
hache = abs(hash(kmer))
for h, rang in mphf:
if h == hache:
return rang
return -1
def create_hash_table(set_kmer, n):
"""
Crée une table de hachage à partir d'un ensemble de k-mers et d'une mphf
Parameters:
set_kmer (set): Ensemble de k-mers.
n (int): Taille de la table de hachage.
Returns:
list: Table de hachage créée à partir des k-mers
mphf: la mphf
Examples:
>>> set_kmer = {'ATCG', 'TGCA', 'GCTA'}
>>> n = 10
>>> tableau = create_hash_table(set_kmer, n)
>>> len(tableau) == n
True
>>> all(kmer in tableau for kmer in set_kmer)
True
"""
mphf = construction_mphf(set_kmer, n) # créer la mphf pour les kmers
# initialiser un tableau de taille n (une liste)
tableau = [None] * n
# écrire les kmers aux adresses du tableau données par la mphf
for kmer in set_kmer:
adresse = get_hash_mphf(mphf, kmer)
if adresse == -1:
print(f"Erreur : Impossible de trouver l'adresse pour {kmer} (MPHF renvoie -1)")
continue
if 0 <= adresse < n:
tableau[adresse] = kmer
return tableau, mphf # retourner le tableau et la mphf
def generer_kmers(n, k):
'''
genere un set de n k-mers
'''
kmers = set()
while len(kmers) < n:
kmer = ''.join(random.choice('ATCG') for _ in range(k))
kmers.add(kmer)
return kmers
def compare_taille(n_max, fichier_sortie):
n_values = []
table_size = []
dict_size = []
k = 21
for n in range(100, n_max, 1000):
set_kmer = generer_kmers(n, k)
tableau, mphf = create_hash_table(set_kmer, n)
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 ?
# Car sys.getsizeof(tableau) ne mesure que la liste elle-même, pas les objets stockés dedans.
# On veut mesurer la mémoire totale du système de hachage, pas seulement la liste.
dict_size.append(sys.getsizeof(set_kmer))
plt.plot(n_values, table_size, label='Table avec MPHF')
plt.plot(n_values, dict_size, label='Dict')
plt.xlabel('n')
plt.xticks(n_values, [str(x) for x in n_values], rotation=45)
plt.ylabel('Taille (octets)')
plt.title('Évolution de la taille de la table de hachage avec MPHF et du dict')
plt.legend()
plt.savefig(fichier_sortie)
plt.close()
# dé-commenter quand vous êtes prêts, expliquer les résultats
compare_taille(10000, "mphf.png")
# Sur le graphe obtenu, on observe que la taille de la table de hachage du dictionnaire augmente par paliers,
# alors que celle de la MPHF augmente de manière linéaire, et beaucoup plus progressivement.
# Cela est cohérent, en effet le dictionnaire va allouer plus d'espace dès que le nombre d'éléments atteint un seuil.
# Quant à la MPHF, elle minimise la mémoire en évitant les collisions.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment