travailllage

Partiton.py

-import numpy as np
-import matplotlib.pyplot as plt
-import math
-import random
-from collections import namedtuple
-import pandas
-from typing import *
-
-Point = namedtuple('Point', 'x y')
-
-def point_moyen(ensemble: set[Point]) -> Point:
-    if not ensemble:
-        raise ValueError("Impossible de calculer le point moyen d'un ensemble vide")
-    moy_x = sum([i.x for i in ensemble]) / len(ensemble)
-    moy_y = sum([i.y for i in ensemble]) / len(ensemble)
-    return Point(moy_x, moy_y)
-
-def distance(point_a: Point, point_b: Point) -> float:
-    carre_x = (point_a.x - point_b.x) ** 2
-    carre_y = (point_a.y - point_b.y) ** 2
-    return carre_x + carre_y
-
-
-def methode_a(data: set[Point], liste_init: list[Point], iter_max: int=25) -> list[set[Point]] :
-    '''Sépare un ensemble de points en partitions de points en fonction de leur distance.
-    L'efficacité n'est pas garantie et dépend du hasard et de la liste de départ.
-
-    Args:
-        data (set[Point]): L'ensemble des points qu'il faut partitionner.
-        liste_init (list[Point]): Une liste contenant autant de points qu'il y a de partitions. Peut être généré au hasard, même si c'est suboptimal.
-        iter_max (int, optional): Le nombre d'itérations du programme. Plus d'itérations signifie plus de précision. 25 par défaut.
-
-    Returns:
-        list[set[Point]]: L'ensemble data divisé en partitions
-    '''
-    K = len(liste_init)
-
-    # Cette liste contiendra le point moyen de chaque partition.
-    # Elle sera mise à jour à chaque itération.
-    # Son utilité est de determiner de quelle partition un point est le plus proche.
-    liste_moyennes = list(liste_init)
-
-    for _ in range(iter_max): # Limite d'itération
-        # initialisation avec K sets vides.
-        # La liste sera réécrite à chaque itération pour devenir de plus en plus précise.
-        res = [set() for _ in range(K)]
-
-        # Déterminer de quel point moyen chaque point est le plus proche.
-        for point in data:
-            mini = float('inf') # infini, initialisation de l'algo de min
-            indice_mini = -1
-            for i, moyen in enumerate(liste_moyennes):
-                if distance(point, moyen) < mini:
-                    mini = distance(point, moyen)
-                    indice_mini = i
-            res[indice_mini].add(point)
-
-        # Définition des nouvelles moyennes pour devenir de plus en plus précis.
-        for k in range(K):
-            if res[k]:
-                liste_moyennes[k] = point_moyen(res[k])
-            else:
-                liste_moyennes[k] = random.choice(tuple(data))
-    return res
-
-def points_moyens_partitions(partitions: list[set[Point]]) -> list[Point]:
-    '''Retourne le point moyen de chaque partition.
-    '''
-    return [point_moyen(i) for i in partitions]
-
-def plot_partitions(partitions: list[set[Point]], titre: str) -> None:
-    '''Enregistre un graphique des partitions en pdf.
-    '''
-    if not titre or titre == '.pdf':
-        raise ValueError('Le fichier doit avoir un nom')
-    if not titre.endswith('.pdf'):
-        raise ValueError('Ce n\'est pas un nom de pdf')
-    for p in partitions:
-        x = [i[0] for i in p]
-        y = [i[1] for i in p]
-        plt.scatter(x, y)
-    plt.savefig(titre)
-
-def lire_fichier(chemin: str) -> set[Point]:
-    with open(chemin, 'r') as f:
-        data = pandas.read_csv(chemin)
-    return {Point(i['0'], i['1']) for _, i in data.iterrows()}
-
-def main() :
-    ensemble = lire_fichier('donnees_test/data0.csv')
-    parts = methode_a(ensemble, random.sample(tuple(ensemble), 4), 100)
-    plot_partitions(parts, 'methode_a.pdf')
-
-if __name__ == "__main__" :
-    main()
\ No newline at end of file

main.py

+import src
+
+def main() :
+    src.methode_a_exemple('pdf/meth_a.pdf')
+    src.methode_a_coude_exemple('pdf/inertie.pdf')
+
+if __name__ == '__main__':
+    main()
+    # print(min([0, 1, 2,3], key=lambda x: float('inf') if x == 0 else x))
\ No newline at end of file

src/__init__.py

+from .methodes import *
+from .plot import *
+from .fun import *
\ No newline at end of file

src/fun.py

+from collections import namedtuple
+import pandas
+from typing import *
+
+Point = namedtuple('Point', 'x y')
+
+def point_moyen(ensemble: set[Point]) -> Point:
+    '''Retourne un point avec les coordonnées moyennes de l'ensemble de points
+
+    Args:
+        ensemble (set[Point]): L'ensemble de points dont la moyenne doit être calculée
+
+    Raises:
+        ValueError: Si l'ensemble est vide
+
+    Returns:
+        Point: Un Point avec les coordonnées moyennes
+    '''
+    if not ensemble:
+        raise ValueError("Impossible de calculer le point moyen d'un ensemble vide")
+    moy_x = sum([i.x for i in ensemble]) / len(ensemble)
+    moy_y = sum([i.y for i in ensemble]) / len(ensemble)
+    return Point(moy_x, moy_y)
+
+def distance(point_a: Point, point_b: Point) -> float:
+    '''Retourne le carré de la distance entre deux points avec la formule d'Euclide
+
+    Args:
+        point_a (Point): premier point
+        point_b (Point): deuxième point
+
+    Returns:
+        float: distance entre les points
+    '''
+    carre_x = (point_a.x - point_b.x) ** 2
+    carre_y = (point_a.y - point_b.y) ** 2
+    return carre_x + carre_y
+
+def points_moyens_partitions(partitions: list[set[Point]]) -> list[Point]:
+    '''Retourne le point moyen de chaque partition.
+    '''
+    return [point_moyen(i) for i in partitions]
+
+def lire_fichier(chemin: str) -> set[Point]:
+    '''Retourne un ensemble de points selon les coordonnées d'un csv
+    '''
+    with open(chemin, 'r') as f:
+        data = pandas.read_csv(chemin)
+    return {Point(i['0'], i['1']) for _, i in data.iterrows()}
+
+def inertie(partitions: list[set[Point]]) -> float:
+    moy = points_moyens_partitions(partitions)
+    res = 0
+    for k in range(len(partitions)):
+        for p in partitions[k]:
+            res += distance(p, moy[k])
+    return res
+
+if __name__ == '__main__':
+    pass
\ No newline at end of file

src/methodes.py

+import math
+import random
+from typing import *
+from .fun import *
+
+
+
+def methode_a(data: set[Point], liste_init: list[Point], iter_max: int=25) -> list[set[Point]] :
+    '''Sépare un ensemble de points en partitions de points en fonction de leur distance.
+    L'efficacité n'est pas garantie et dépend du hasard et de la liste de départ.
+
+    Args:
+        data (set[Point]): L'ensemble des points qu'il faut partitionner.
+        liste_init (list[Point]): Une liste contenant autant de points qu'il y a de partitions. Peut être généré au hasard, même si c'est suboptimal.
+        iter_max (int, optional): Le nombre d'itérations du programme. Plus d'itérations signifie plus de précision. 25 par défaut.
+
+    Returns:
+        list[set[Point]]: L'ensemble data divisé en partitions
+    '''
+    K = len(liste_init)
+
+    # Cette liste contiendra le point moyen de chaque partition.
+    # Elle sera mise à jour à chaque itération.
+    # Son utilité est de determiner de quelle partition un point est le plus proche.
+    liste_moyennes = list(liste_init)
+    ancien_res = res = [set() for _ in range(K)]
+    for _ in range(iter_max): # Limite d'itération
+        # initialisation avec K sets vides.
+        # La liste sera réécrite à chaque itération pour devenir de plus en plus précise.
+        res = [set() for _ in range(K)]
+
+        # Déterminer de quel point moyen chaque point est le plus proche.
+        for point in data:
+            mini = float('inf') # infini, initialisation de l'algo de min
+            indice_mini = -1
+            for i, moyen in enumerate(liste_moyennes):
+                if distance(point, moyen) < mini:
+                    mini = distance(point, moyen)
+                    indice_mini = i
+            res[indice_mini].add(point)
+
+        # Définition des nouvelles moyennes pour devenir de plus en plus précis.
+        for k in range(K):
+            if res[k]:
+                liste_moyennes[k] = point_moyen(res[k])
+            else:
+                liste_moyennes[k] = random.choice(tuple(data))
+        if res == ancien_res:
+            break
+        ancien_res = res
+    return res
+MethodA = methode_a
+
+if __name__ == '__main__':
+    pass
\ No newline at end of file

src/plot.py

+from matplotlib import pyplot as plt
+import numpy as np
+from .methodes import *
+from .fun import *
+
+def plot_partitions(partitions: list[set[Point]], titre: str) -> None:
+    '''Enregistre un graphique des partitions en pdf.
+    '''
+    if not titre or titre == '.pdf':
+        raise ValueError('Le fichier doit avoir un nom')
+    if not titre.endswith('.pdf'):
+        raise ValueError('Ce n\'est pas un nom de pdf')
+
+    _, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))
+    ax1.scatter([x[0] for p in partitions for x in p], [x[1] for p in partitions for x in p], color='blue')
+    ax1.set_title('Données brutes')
+
+    for p in partitions:
+        x = [i[0] for i in p]
+        y = [i[1] for i in p]
+        ax2.scatter(x, y)
+    ax2.set_title('Application de la méthode A')
+    plt.tight_layout()
+    plt.savefig(titre)
+
+def methode_a_exemple(titre: str) -> None:
+    '''Affiche les partitions créées par la méthode a sur un fichier arbitraire et sauvegarde en pdf
+    '''
+    ensemble = lire_fichier('donnees_test/data0.csv')
+    parts = methode_a(ensemble, random.sample(tuple(ensemble), 4), 100)
+    plot_partitions(parts, titre)
+MethodAExample = methode_a_exemple
+
+def methode_a_coude(donnees: set[Point], nb_classes_max: int, titre: str) -> None:
+    _, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))
+    ax1.scatter([x[0] for x in donnees], [x[1] for x in donnees], color='blue')
+    ax1.set_title('Données brutes')
+    x = np.arange(1, nb_classes_max+1)
+    liste_partitions = [methode_a(donnees, random.sample(tuple(donnees), k)) for k in x]
+    y = [inertie(part) for part in liste_partitions]
+    ax2.plot(x, y)
+    ax2.set_title('Inertie en fonction du nombre de partitions')
+    plt.savefig(titre)
+
+MethodAElbow = methode_a_coude
+
+def methode_a_coude_exemple(titre: str):
+    ensemble = lire_fichier('donnees_test/data0.csv')
+    methode_a_coude(ensemble, 9, titre)
+if __name__ == '__main__':
+    pass
\ No newline at end of file