En quelques lignes, voici un petit compte rendu d’une visite de la tombe de H.P. Lovecraft lors d’un voyage dans la région de Providence. Ce voyage a eu lieu il y a bientôt quinze ans, j’ai rédigé ce petit compte rendu en plusieurs fois, il y a forcément des erreurs et des oublis…

Contexte

Je me suis rendu en nouvelle Angleterre du 25 au 31 octobre 2003 pour un déplacement professionnel (conférence Wavelet applications in industrial processing). Nous avons pris un Paris-Boston au départ de Roissy Charles de Gaulle. À l’époque, pas de visa, seulement la carte verte à cocher dans l’avion avant de poser le pied sur le sol américain.

Nous sommes allés à Boston puis à Providence. La ville de Boston est très intéressante pour le touriste qui connaît l’histoire américaine. En effet, c’est une des villes les plus anciennes. Dans Boston, les buildings de verre côtoient les églises en brique et les vieux cimetières (où reposent un certain nombre de héros de l’Union). Le parcours de la Freedom Trail permet de réviser ses cours d’histoire de l’indépendance des U.S.A. En automne, la ville est superbe, les arbres étant de toutes les couleurs.

Nous nous sommes ensuite rendus à Providence (qui est très proche de Boston) pour la conférence (y’a bien un moment où il faut bosser !). D’un point de vue touristique, Providence n’est pas exceptionnelle… Nous avons clos notre séjour avec la visite du Swan Point Cemetery après la conférence.

Visite au cimetière

Le Swan Point Cemetery est situé dans un quartier résidentiel de Providence. C’est un des plus grands (le plus grand ?) cimetière fédéral américain. Nous l’avons trouvé assez facilement grâce aux explications de l’agent d’accueil de notre hôtel ; il nous a même rédigé un guide complet pour si rendre.

Les cimetières américains sont très différents des cimetières français. En effet, il s’agit de grands parcs boisés (voir les photos jointes). Un grand parking permet de garer sa voiture. A l’entrée se trouve une chapelle (où sont les toilettes ! ) et un bâtiment d’accueil. Nous nous sommes rendus à l’accueil où il n’y avait personne. Une borne d’accueil équipée d’un écran tactile permet de localiser une tombe et d’imprimer le plan pour s’y rendre. Bien pratique pour se promener dans un parc de plusieurs hectares !

En sortant du bâtiment, nous sommes tombés nez à nez avec la conservatrice, un de ses collègues et un garde du parc avec lesquels nous avons discuté. Elle nous a proposé d’être conduit par l’un des gardes en voiturette jusqu’à la tombe de H.P. Lovecraft. La promenade était bien trop belle pour ne pas la faire à pied !

Il nous a été signifié qu’il était interdit de prendre des photos des tombes à cause du droit à l’image. Les seules photos autorisées doivent être en cadre large sans tombe clairement identifiable. Dès l’instant où le garde porte une bombe au poivre clairement visible, on n’a pas vraiment de bonne raison de ne pas respecter les consignes

Sur la pierre tombale, des gens ont déposé des cailloux, des pièces de monnaie, et une petite bouteille de parfum vide. J’ai aussi posé une pièce (aucun effet indésirable constaté… aucun effet favorable non plus !).

Pour finir

Comme dit le proverbe : « l’occasion fait le larron », aller à Providence juste pour marcher dans les pas de Lovecraft ne me semble pas justifier un billet d’avion. Par contre, Boston et la Nouvelle Angleterre sont magnifiques en automne et dans ce cas, le détour n’est pas long…

Un étudiant m’a demandé d’expliquer comment le problème était résolu, j’ai donc rédigé ces quelques lignes pour donner les grandes idées.

Les données du problème

A partir des fiches de vœux des étudiants une feuille de calcul est remplie avec une valeur représentant l’intérêt des étudiants pour le sujet. La valeur maximale de l’intérêt est donnée au premier sujet choisi par les étudiants et ainsi de suite. Les sujets qui n’ont pas été choisis par un groupe ont un intérêt de 0.

Les données peuvent être présentées ensuite sous la forme d’un tableau ayant l’aspect ci-dessous. Les lignes représentent les groupes (ici repérés de A à F) et les colonnes les sujets (repérés de 1 à 12). Le tableau est rempli à la main sous LibreOffice et exporté au format CSV (on peut aussi faire le CSV dans un éditeur de texte) en prenant soin d’ajouter un # dans la première colonne, il nous servira ensuite de marqueur pour repérer la première ligne.

Le fichier CSV est donc le suivant :

# Voeux,Sujet 1,Sujet 2,Sujet 3,Sujet 4,Sujet 5,Sujet 6,Sujet 7,Sujet 8,Sujet 9,Sujet 10,Sujet 11,Sujet 12
Groupe A,0,0,0,0,0,0,0,5,4,3,2,1
Groupe B,5,0,4,0,3,0,2,0,1,0,0,0
Groupe C,5,4,3,2,1,0,0,0,0,0,0,0
Groupe D,0,0,0,0,0,0,5,4,3,2,1,0
Groupe E,0,0,0,0,0,0,0,1,2,3,4,5
Groupe F,0,0,5,0,4,0,3,0,2,0,1,0

Lecture des données

A partir du fichier CSV il faut extraire trois tableaux :

• le premier contenant les groupes
• le deuxième contenant les sujets
• le troisième (2D) contenant les vœux.

La disposition des données dans le fichier CSV permet de construire le tableau des sujets avec la première ligne. Ensuite le tableau contenant les groupes et le tableau contenant les vœux sont remplis au fur et à mesure de la lecture du fichier.

A partir de la double liste contenant les vœux, on construit un tableau de type numpy.array (avec le temps je travaille de plus en plus avec numpy pour les représentations de tableau).

import sys
import csv
import numpy as np

def lire_voeux(fic="exemple.csv"):
    tmp = []
    groupes = []
    voeux = []
    with open(fic) as fic:
        reader = csv.reader(fic, delimiter=',')
        for ligne in reader:
            if '#' in ligne[0]:
                tmp, sujets = ligne[0], ligne[1:]
            else:
                groupe, voeux_ = ligne[0], [int(_) for _ in ligne[1:]]
                groupes.append(groupe)
                voeux.append(voeux_)
    return sujets, groupes, np.array(voeux)

La fonction retourne les 3 tableaux qui seront utilisés par la suite.

Approche exhaustive

Ce problème rentre dans la catégorie des problèmes d’affectation, de nombreux algorithmes existent (algorithme hongrois,…) et il doit être possible de résoudre ce problème en modifiant les algorithmes existants. Je n’ai pas pris le temps de réfléchir à un algorithme complet permettant de résoudre ce problème.

Espace de recherche

Parmi l’ensemble des sujets proposés il est possible que certains ne soient pas du tout retenus par les étudiants. A l’inverse, il faut qu’il y ait au moins autant de sujet retenus (indépendant de leurs position) que de groupes d’étudiants (dans ce cas il risque toutefois d’avoir beaucoup d’étudiants insatisfaits).

L’utilisation d’un numpy.array  pour représenter les vœux permet de vérifier tout ça rapidement. La somme de chaque colonne (selon la représentation de notre tableau ci-dessus) permet de retrouver ensuite facilement les sujets qui n’ont jamais été retenus par les étudiants. Le nombre de sujets retenus doit être supérieur ou égal au nombre de groupes sinon le problème est insolvable.

somme_voeux = np.sum(voeux, axis=0)
sujets_possibles = np.where(somme_voeux>0)[0]
if (sujets_possibles.shape[0]<len(groupes)):
   print("Pas assez de sujets retenus")
   sys.exit()

Représentation d’une solution

Dans l’exemple précédent le tableau sujets_possibles contient [ 0 1 2 3 4 6 7 8 9 10 11]. Le sujet 6 (ayant l’indice 5 dans le tableau) n’ayant pas été retenu par les étudiants.

Une solution au problème est représentée par un tableau ayant pour taille le nombre de groupes. Chaque cas du tableau contenant l’indice du sujet (dans le tableau sujets).

La solution présentée précédemment s’écrit simplement en Python avec un tranche dans la liste sujets_possibles.

solution = sujets_possibles[0:len(groupes)]

Qualité d’une solution

Partant d’une solution il faut être capable d’évaluer la qualité de la proposition, après avoir lu dans le tableau choix la satisfaction de chaque groupe plusieurs approches peuvent être utilisées :

• calculer la moyenne,
• rechercher l’amplitude et le nombre de vœux minimaux (on cherchera donc à minimiser ce critère),
• rechercher l’amplitude et le nombre de vœux maximaux,
• …

Nous allons simplement utiliser la moyenne de la satisfaction comme qualité d’une proposition d’attribution de projets.

Pour chaque groupe on cherche le sujet qui lui a été attribué (contenu dans la liste attributions passée en paramètre) et on recherche dans le tableau des vœux la valeur d’intérêt pour ce projet.

On somme ces valeurs pour tous les groupes et on calcule la moyenne. Le but va être de maximiser cette valeur. Dans le cas ci-dessus, idéalement il faudrait une moyenne de 5 (ce qui signifierait que tous les groupes ont eu leur premier vœu).

def __calculer_satisfactions(attributions, voeux):
    somme = 0.0
    for idx,sujet in enumerate(attributions):
        somme += voeux[idx][sujet]
    return somme/len(attributions)

La solution initiale présentée ci-dessus donne les valeurs suivantes :

La satisfaction totale est de 6 et la satisfaction moyenne est de 1. La solution est très mauvaise, la majorité des groupes ayant des sujets qu’ils ne voulaient pas.

 Recherche de la meilleure solution

Le problème du choix de éléments parmi avec prise en compte de l’ordre est un arrangement. Le nombre d’arrangement possible est :

$$A^k_n = \frac{n!}{(n-k)!}\quad\mbox{pour }k\leq n $$

Le nombre possible explose en fonction du nombre de groupes (et du nombre de vœux possibles),  est bornée par le produit entre le nombre de groupes et le nombre de voeux et vaut le nombre de groupe.

Dans l’exemple précédent (5 vœux, 6 groupes et 11 vœux retenus) le nombre de combinaisons est de 332640.

En Python le module itertools permet de traiter les différents cas de permutations, combinaisons, arrangement,… A partir des sujets_possibles la liste des solutions possibles est construite avec :

solutions_possibles = list(itertools.permutations(sujets_possibles, len(groupes)))
print("Nombre de combinaisons : ", len(solutions_possibles))

L’ensemble des solutions étant construit, il reste à rechercher la meilleure (ou les meilleures, il peut y avoir plusieurs solutions optimales). Une simple compréhension de liste sur les solutions possibles qui utilise la fonction __calculer_satisfaction précédemment écrite permet de trouver la qualité de toutes les solutions. Ensuite il suffit de recherche la valeur maximale et la solution associée :

valeurs_solutions = [__calculer_satisfactions(_, voeux) for _ in solutions_possibles]
meilleur_satisfaction = max(valeurs_solutions)
meilleur_solution = valeurs_solutions.index(meilleur_satisfaction)

La solution (dans ce cas elle est unique) est :

La satisfaction moyenne est de 4,83. Tous les groupes ont leurs premiers vœux sauf le groupe C qui obtient son deuxième vœu.

Approche heuristique

La construction de l’ensemble des solutions possibles devient très vite impossible en un temps (et une quantité de mémoire) raisonnable. Cette année nous avons (sur les deux promotions) une vingtaine de groupe et une trentaine de sujet, le nombre de solutions est d’environ . Je n’ai pas cherché à vérifier si Python pouvait gérer des listes de cette taille mais je suis certain de connaître la réponse ! Pour des problèmes ayant un très grand espace de recherche les heuristiques sont souvent utilisées.

Modification d’une solution

Le tableau sujets_possibles contient tous les sujets retenus par les étudiants. La solution du problème est construite à partir d’une tranche contenant les premiers éléments.

solution = sujets_possibles[0:len(groupes)]

La permutation de deux éléments dans l’ensemble des sujets possibles peut conduire à une meilleure solution. Pour éviter de calculer des solutions inutiles (celles pour lesquelles les permutations sont hors du tableau solution) l’intervalle de tirage de l’un des deux éléments est limité à l’intérieur de solution.

Après la permutation des éléments, l’efficacité de la solution est calculée, si elle est plus mauvaise que la valeur précédente, les éléments permutés sont replacés à leurs positions initiales. Cette séquence est répétée pendant quelques milliers d’itérations.

import random 
#...
def attribuer_projet_aleatoire(groupes, sujets, voeux):
    NB_REP = 2000
    somme_voeux = np.sum(voeux, axis=0)
    sujets_possibles = np.where(somme_voeux > 0)[0]

    if (sujets_possibles.shape[0] < len(groupes)):
        print("Pas assez de sujets retenus")
        exit(1)

    evolutions = np.zeros(NB_REP)
    for _ in range(NB_REP):
        satisfaction = __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux)
        evolutions[_] = satisfaction

        a = random.randint(0,len(groupes)-1)
        b = random.randint(0, sujets_possibles.shape[0]-1)
        sujets_possibles[b], sujets_possibles[a] = sujets_possibles[a], sujets_possibles[b]
        satisfaction_ = __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux)

        if satisfaction > satisfaction_:
            sujets_possibles[b], sujets_possibles[a] = sujets_possibles[a], sujets_possibles[b]

    return __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux), sujets_possibles[0:len(groupes)], evolutions

La fonction s’appelle à partir des éléments construit précédemment, elle retourne la satisfaction moyenne finale, l’attribution des projets et l’évolution de la satisfaction (afin de construire ensuite les graphiques d’évolution)

satisfaction, attributions, evolutions = attribuer_projet_aleatoire(groupes, sujets, voeux)

Résultats

Dans le cas de l’exemple proposé il est facile de vérifier l’efficacité de l’algorithme :  la solution globale est connue et le nombre de permutations possible est connu. Dans les illustrations ci-dessous l’algorithme a réalisé 2000 itérations (à comparer aux 332640 cas possibles).

Avec 2000 itérations, l’algorithme a calculé 0.6% des permutations possibles, ce qui représente un temps de calcul et une occupation en mémoire bien inférieur à la recherche de la solution de manière exhaustive (sous réserve quelle soit possible).

Dans certains cas, l’algorithme ne converge pas vers la solution globale et se trouve pris dans un optimum local.

Dans l’exemple ci-contre le maximum global n’a pas pu être atteint. L’algorithme a convergé vers un maximum local. Dans le cas de notre problème il s’agit d’une solution pas trop mauvaise qui ne pourrait être améliorée qu’en réalisant plusieurs permutations (avec certaines qui conduiraient à une solution plus mauvaise).

Amélioration avec un algorithme de recuit simulé

Pour quitter les optimums locaux, il est nécessaire d’utiliser un algorithme capable de réaliser des modifications plus importantes que la permutation de 2 éléments. J’ai choisi de manière arbitraire d’utiliser un algorithme de recuit simulé qui est simple à coder et qui donne souvent de bons résultats pour ce type de problèmes.

Principe

L’algorithme du recuit simulé est une métaheuristique permettant de minimiser la fonction d’énergie d’un système. La configuration du système est modifiée de manière élémentaire à chaque itération de l’algorithme. La variation d’énergie du système est ensuite calculée :

• si l’énergie est diminuée, la nouvelle configuration du système est conservée.
• si l’énergie est augmentée, la nouvelle configuration a une probabilité (donc comprise entre 0 et 1) d’être retenue donnée par . Cette probabilité d’acceptation liée à une fonction exponentielle décroissante est appelée règle de Métropolis.

La température est diminuée au fur et à mesure des itérations de l’algorithme. La probabilité d’accepter une mauvaise solution décroît donc en fonction du temps.

Application

L’application de l’algorithme du recuit simulé à notre problème est assez simple. L’énergie du système correspond à la valeur de satisfaction à la nuance près qu’il faut la maximiser (et pas la minimiser comme dans l’algorithme de recuit simulé).

Une variation de la configuration du système est simplement la permutation de deux éléments dans le tableau des sujets retenus (comme dans le programme précédent).

Réglage des différents paramètres

Les algorithmes basés sur des métaheuristiques sont souvent compliqués à régler. Les paramètres sont nombreux et souvent interdépendants. Dans le cas du recuit il existe toutefois quelques règles empiriques qui permettent d’obtenir de bons résultats et une convergence rapide.

Estimation de la variation moyenne

Pour pouvoir fixer la température initiale il est nécessaire de connaître une estimation de la variation moyenne de l’énergie notée . Il est assez simple d’estimer cette variation en réalisant quelques centaines de permutations et en relevant la variation de la satisfaction pour chaque permutation.

def __calcul_variation_moyenne(voeux,NB=500):
    diff = 0
    somme_voeux = np.sum(voeux, axis=0)
    sujets_possibles = np.where(somme_voeux > 0)[0]
    satisfaction = __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux)

    for _ in range(NB):
        a = random.randint(0,len(groupes)-1)
        b = random.randint(0, sujets_possibles.shape[0]-1)
        sujets_possibles[b], sujets_possibles[a] = sujets_possibles[a], sujets_possibles[b]
        satisfaction_ = __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux)
        diff += np.abs(satisfaction_ - satisfaction)
        satisfaction = satisfaction_

    return diff / NB

La fonction est utilisée lors de l’initialisation de l’algorithme de recuit simulé pour calculer la température initiale.

Température initiale

La température initiale est donnée par :
Le facteur fixe la probabilité initiale d’acceptation des « mauvaises solutions ». Ce taux est souvent compris entre 50 % (cas d’une configuration de départ de mauvaise qualité) et 20 % (configuration de départ de qualité correcte).

delta_E = __calcul_variation_moyenne(voeux)
T_0 = (-1.0 * delta_E) / np.log(0.50)
T = T_0

Évolution de la température

La température doit diminuer pour que l’algorithme converge (pour que la probabilité d’acceptation des « mauvaises » solutions diminue). Plusieurs lois sont utilisées, une solution simple est de multiplier la température par 0,95 après un certain nombre de permutations selon le nombre de variables à optimiser. Pour ce problème, j’ai choisi de mettre à jour la température après 50 permutations. Pour un nombre de sujets/groupes plus important cette valeur doit être augmenté en conséquence (elle pourrait être configurée automatiquement…).

if _ % 50 == 0:
   T = 0.9 * T

Sauvegarde du meilleur rencontré

Puisque l’algorithme conserve des solutions de moins bonnes qualités pour quitter les optimums locaux, il est possible de perdre la meilleure solution trouvée. Pour éviter ce problème il suffit de sauvegarder la meilleure solution connue ainsi que sa valeur.

if satisfaction_>meilleure_satisfaction:
   meilleure_satisfaction = satisfaction_
   meilleure_solution = np.array(sujets_possibles[0:len(groupes)])

Critères d’arrêt

Bien que l’algorithme soit très rapide il peut être intéressant de l’arrêter si certains critères sont vérifiés :

• la satisfaction a atteint le maximum possible (donc ici 5)
• la satisfaction stagne pendant plusieurs centaines d’itérations ; l’écart type des valeurs est donc très faible.

if meilleure_satisfaction==5 or (_>200 and np.std(evolutions[_-200:_])<0.0001):
   return meilleure_satisfaction, meilleure_solution, evolutions

Code complet

Les morceaux de programme présentés ci-dessus sont assemblés pour construire la fonction complète.

def attribuer_projet_recuit(groupes, sujets, voeux):
    NB_REP = 2000
    # Extraction des sujets retenus
    somme_voeux = np.sum(voeux, axis=0)
    sujets_possibles = np.where(somme_voeux > 0)[0]  # Seulement les non nuls
    if (sujets_possibles.shape[0] < len(groupes)):
        print("Pas assez de sujets retenus")
        sys.exit()

    evolutions = np.zeros(0)
    # Calcul de la variation moyenne
    delta_E = __calcul_variation_moyenne(voeux)
    T_0 = (-1.0 * delta_E) / np.log(0.50)
    T = T_0
    # Sauvegarde du meilleur rencontré
    meilleure_satisfaction = __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux)
    meilleure_solution = sujets_possibles[0:len(groupes)]

    satisfaction = meilleure_satisfaction

    for _ in range(NB_REP):
        # Mise à jour de la température
        if _ % 50 == 0:
            T = 0.9 * T
        # Valeurs de permutations
        a = random.randint(0, len(groupes) - 1)
        b = random.randint(0, sujets_possibles.shape[0] - 1)
        sujets_possibles[b], sujets_possibles[a] = sujets_possibles[a], sujets_possibles[b]
        satisfaction_ = __calculer_satisfactions(sujets_possibles[0:len(groupes)], voeux)
        diff = satisfaction_ - satisfaction
        # Valeurs pour le recuit
        r = np.random.random()
        seuil = np.exp(1.0 * diff / T)
        # Solution trop mauvaise pour le recuit
        if diff < 0 and r > seuil:
            sujets_possibles[b], sujets_possibles[a] = sujets_possibles[a], sujets_possibles[b]
        else:
            satisfaction = satisfaction_
        # Sauvegarde de la meilleur solution
        if satisfaction_>meilleure_satisfaction:
            meilleure_satisfaction = satisfaction_
            meilleure_solution = np.array(sujets_possibles[0:len(groupes)])

        evolutions = np.append(evolutions, satisfaction)

        # Conditions d'arrêt
        if meilleure_satisfaction==5 or (_>200 and np.std(evolutions[_-200:_])<0.0001):
            return meilleure_satisfaction, meilleure_solution, evolutions

    return meilleure_satisfaction, meilleure_solution, evolutions

Résultats

Il n’y a pas de garantie théorique que l’optimum global soit attend par l’algorithme. En pratique, si on exécute plusieurs fois l’algorithme, l’optimum est généralement atteint en un nombre assez faible d’itérations.

La valeur de la satisfaction moyenne n’évolue plus de manière monotone car le recuit autorise des « mauvaises » solutions.  Le recuit permet de quitter les optimums locaux et d’attendre l’optimum globale. Aux environs des 700 itérations, l’apport du recuit est bien visible :  l’algorithme convergeait vers une solution locale de 4,66 avant le recuit, le recuit a permis de trouver la valeur 4,83

Le critère d’arrêt sur la stabilité a arrêté l’algorithme en moins de 1000 itérations (il faut prendre en compte celle qui ont été nécessaire pour calculer la variation moyenne nécessaire pour fixer les paramètres de l’algorithme).

Mise en œuvre

Cette année nous avons 20 groupes de projets qui ont retenu au total 26 sujets différents. Le calcul de l’arrangement conduit à possibilités. Il évident qu’il n’est pas possible de les vérifier toutes (même si beaucoup sont impossibles à proposer car attribuant un sujet qui n’a pas été retenu à un ou plusieurs groupes). Les différents paramètres de l’algorithme sont les suivants :

• le nombre de répétitions est augmenté à 10000
• la température est actualisée toutes les 250 itérations
• la convergence est fixée pour un écart-type très faible après 5000 itérations

L’algorithme converge en quelques secondes. J’ai réalisé des répétitions qui ont montré que plusieurs configurations différentes semblaient conduire au maximum possible (il n’est pas certain que ce soit le maximum, mais c’est fort probable…).

Inventaire des différentes solutions

Puisque le problème admet plusieurs solutions équivalentes, l’algorithme ne peut pas choisir la meilleure. La solution la plus simple est d’essayer de faire l’inventaire des solutions possibles et de les stocker dans un fichier.

Pour construire un inventaire des solutions possible, la fonction attribuer_projet_recuit va être appelée plusieurs fois et les résultats des différentes itérations vont être stockés. La satisfaction maximale est ensuite recherchée.

Chaque solution telle que sa valeur de satisfaction soit égale à la satisfaction maximale est ensuite stockée dans un set ce qui assure l’unicité de la solution dans l’ensemble des solutions qui seront conservées. La solution doit être transformée en tuple (qui est immuable) pour pouvoir être stockée dans l’ensemble meilleures_solutions. Après le remplissage de l’ensemble des meilleures_solutions, il ne reste plus qu’à écrire les éléments dans un fichier CSV :

• la première ligne contient les noms des groupes
• les lignes suivantes stocke les différentes configurations possibles.

def recherches_multiples(groupes, sujets, voeux, nb_rep=100, fic="solutions.csv"):
    solutions = []
    valeurs = []
    satisfaction_maximale = 0.0
    for _ in range(nb_rep):
        satisfaction, attributions, evolutions = attribuer_projet_recuit(groupes, sujets, voeux)
        solutions.append(attributions)
        valeurs.append(satisfaction)
    satisfaction_maximale = max(valeurs)
    print("Satisfaction maximale : ", satisfaction_maximale)
    meilleures_solutions = set()
    for s, v in zip(solutions, valeurs):
        if v == satisfaction_maximale:
            meilleures_solutions.add(tuple(s))  
    print("%d configurations différentes trouvées"%(len(meilleures_solutions)))
    with open(fic, 'w') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(groupes)
        for s in meilleures_solutions:
            writer.writerow([sujets[int(_)] for _ in s])

Le fichier CSV obtenu peut ensuite être mis en forme avec Libre Office et envoyé aux enseignants qui trancheront .

Notes

Les éléments de code n’ont pas nécessairement été écrit de manière optimale mais plutôt de telle manière que les points principaux des explications puissent être retrouvés dans le code.

Les valeurs de pondérations associées aux vœux des étudiants peuvent être modifiées en fonctions de différents critères (les enseignants peuvent vouloir privilégier tel ou tel groupe sur un projet,…).

Le livre Métaheuristiques des éditions Eyrolles est une saine lecture pour découvrir et approfondir le sujet.

Tout le code est présent sur un dépôt Gitlab ou sur Github.

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Vérification des données avec la somme MD5

Une solution simple pour vérifier l’intégrité de fichiers est l’utilisation d’une somme de contrôle. Plusieurs algorithme existe, le plus connu reste la somme MD5. La somme MD5 est une « signature » unique (quoique des collisions existent, c’est pour cela qu’il ne faut plus l’utiliser pour de la cryptographie) d’un fichier. La commande md5sum de linux permet de calculer la somme d’un fichier mais aussi (et c’est un peu moins connu) de vérifier des fichiers en utilisant leurs sommes de contrôle.

Création des sommes de contrôle

Les sommes de contrôle sont calculées avec un groupement d’instructions assez simple :

• un find permet de retrouver tous les fichiers
• un xargs permet d’utiliser les noms de fichiers (en spécifiant \n comme caractère de séparation pour que les noms de fichiers comportant des espaces soient bien pris en compte).
• le calcul de la somme MD5 est réalisé par md5sum.

Le résultat des somme est placé dans un fichier stocké dans le répertoire temporaire (/tmp), il sera automatiquement supprimé par le système. En une ligne (exécutée dans le répertoire source) ça donne :

find . -type f | xargs -d'\n' md5sum > /tmp/chksum.md5

Vérification des fichiers

La commande md5sum permet aussi de vérifier des fichiers à partir d’une liste de sommes de contrôle avec l’option -c. Dans le répertoire des copies, la commande fait tout le travail de vérification :

md5sum -c /tmp/chksum.md5  1>/dev/null

La redirection de la sortie standard vers /dev/null permet de ne garder l’affichage que des erreurs et donc des fichiers non/mal copiés.

Références

• L’idée générale vient de Michael Simons.
• La différence entre l’option exec et xargs est donnée sur : http://www.tuteurs.ens.fr/unix/exercices/solutions/find-sol.html
• Changer le caractère de fin de bloc pour xargs est détaillé sur Stackoverflow

Enregistrer

La grande majorité des opérations se fait en super-utilisateur ; deux conséquences : il est facile de faire des erreurs et si on ne comprend pas ce que l’on fait, on ne le fait pas ! Ceci était dit, passons au travail…

Fichiers de configuration

Avant de faire une bêtise, le fichier /etc/hosts est sauvegardé avec la commande cp /etc/hosts /etc/hosts.backup. En cas de problème, on pourra revenir à la version initiale du fichier avec mv /etc/hosts.backup /etc/hosts

Configuration par défaut du réseau

Le fichier par défaut sera celui utilisé lorsque la machine n’est pas sur le réseau de la maison. Une copie du fichier hosts initial est faite pour cela cp /etc/hosts /etc.hosts.default

Configuration du réseau pour la maison

Le fichier de configuration pour la maison est construit à partir du fichier par défaut, on fait donc une copie avec cp /etc/hosts /etc/hosts.home. Il est ensuite édité (par exemple avec vim /etc/hosts.home) pour ajouter les résolutions locales :

127.0.0.1	localhost
127.0.1.1	linux

192.168.5.3	serveur1.chezmoi.local
192.168.5.3	serveur2.chezmoi.local
192.168.5.3	serveur3.chezmoi.local

# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

Les trois sites webs pointent vers le même serveur, c’est Nginx qui gère la résolution des différents sites.

Gestion des événements de NetworkManager

La gestion des cartes réseaux est assurée par NetworkManager sous la très grande majorité des systèmes Linux (en tout cas ça marche sur mon Linux Mint !). Une des qualités de NetworkManager est de proposer de gérer les événements associés aux changements d’états des cartes réseaux de manière très simple.

Les scripts traitant les événements doivent être placés dans le répertoire /etc/NetworkManager/dispatcher.d. Le script peut être sauvegardé avec n’importe quel nom (pour respecter la notation générale, je l’ai sauvegardé sous le nom 02home) mais il doit avoir les droits d’exécution pour tous les utilisateurs et doit être la propriété de root (mais comme il faut être super utilisateur pour pouvoir écrire dans ce répertoire ça se fait tout seul…).

Les scripts de changement d’états de NetworkManager doivent traiter deux paramètres lors de l’appel qui sont le nom de la carte réseau concernée et le statut (arrêt, démarrage,…). La carte wifi de mon ordinateur est repérée par wlp1s0 et l’événement qui nous intéresse est la mise en marche de la carte (événement up).

Le script est ensuite assez simple à écrire :

#!/bin/bash -e
IF=$1
STATUS=$2

if [[ $IF = "wlp1s0" ]] && [[ $STATUS = "up" ]]
then
	wifi=`iwlist wlp1s0 scan | grep SSID`
	if [[ $wifi == *"MonWifi"* ]]
	then

	cp /etc/hosts.home /etc/hosts
	fi
else
	#Use the normal host file
	cp /etc/hosts.default /etc/hosts
fi

Le nom du réseau WiFi est obtenu avec la commande iwlist et un grep. On vérifie ensuite que le nom du réseau local (MonWifi) est présent dans la chaîne. Dans ce cas, on copie le fichier de configuration pour la maison dans le fichier /etc/hosts.

Si un autre événement (arrêt, …) se produit sur la carte, le fichier de configuration par défaut est recopié sur /etc/hosts pour tout remettre à la configuration par défaut.

Bilan

Pour l’instant aucun problème ! Je suis toujours surpris par le côté « bien pensé » de Linux et la puissance de petits scripts tout simples…

Bibliographie

• La différence entre les opérateurs [ ] et [[ ]] en bash
• Un exemple de script
• L’idée générale

Les anciens

 Bilan

En 17 ans (!), j’ai changé de téléphone tous les 2 ans et demi en moyenne. Il semblerait que la moyenne nationale soit de 20 mois (ici). Concernant les marques, j’ai tendance à suivre les grandes de l’époque (typiquement Nokia dans les années 2000 et Apple au début des années 2010).

Le nouveau

Comme je l’ai écrit ci-dessus, Apple ronronne depuis plusieurs années, ce qui ne m’encourage pas particulièrement à payer pour un nouvel iPhone. D’autre part j’essaye de plus en plus de mettre en place une autonomie numérique vis-à-vis d’Apple, Google, … donc éviter toutes les solutions de cloud centralisées.

L’idée est de choisir un téléphone assez complet (et pas trop cher…) sur lequel je vais pouvoir installer CyanogenMod et synchroniser les contacts, plannings, notes, mots de passes,… via nextcloud. J’ai aussi choisi un format phablette (diagonale de 5.5 pouces contre 4 pouces pour l’iPhone 5C) car j’utilise pas mal mon smartphone pour lire les mails, faire une recherche rapide sur le web, … par contre je ne joue pas ni ne regarde de vidéos sur mon téléphone donc je ne suis pas exigeant concernant les capacités graphiques.

La transition ne va pas être instantanée entre les contacts, les agendas, les SMS, … Je pense que je vais pouvoir rédiger quelques billets là dessus

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Distribution des séismes et phase de la Lune

Pour vérifier cette affirmation, il faut trouver une liste assez conséquente de séismes et connaître les phases de la Lune pour une date donnée. Évidement, on ne va pas faire ça à la main avec le Quid et l’almanach Vermot…

Source de données

Le « journaliste » expliquait que les données sont disponibles sur Wikipédia. Sur la version française de Wikipédia, je n’ai trouvé que les 10 plus gros tremblements de terre, faire des statistiques sur 10 éléments, c’est pas sérieux… On va donc les prendre sur Wikipedia anglais où l’on trouve une liste des tremblements de terre du XX° siècle ayant une magnitude supérieure à 6. La page est téléchargée avec wget et ensuite, elle est fouillée avec BeautifulSoup pour ne garder que la date et l’intensité des tremblements de terre.

Calculer les phase de la Lune

Il existe de nombreux algorithmes pour calculer les phases de la Lune. Sous Python plusieurs librairies sont disponibles pour les éphémérides, j’ai retenu la librairie pyephem qui permet de nombreux calculs astronomiques.

La librairie permet de calculer le pourcentage de la surface illuminée de la Lune à partir d’une date quelconque. Cette valeur est bien plus précise que la notion de pleine Lune ou de nouvelle Lune.

Script Python

À partir des éléments précédents, j’ai fait un script « à l’arrache » qui pourrait certainement être amélioré.

import bs4 as BeautifulSoup
from datetime import datetime, timedelta
import ephem
import matplotlib.pyplot as plt

fic = open('List_of_20th-century_earthquakes')

html = fic.read()
soup = BeautifulSoup.BeautifulSoup(html, 'html.parser')

intensites = []
phases = []

moon = ephem.Moon()

for line in soup.body.find_all('tr'):
    try:
        td = line.findAll('td')
        date = datetime.strptime(td[0].findAll('span')[1].text, '%B %d, %Y')
        valeur = float(td[6].text)
        moon.compute(date)
        phases.append(moon.moon_phase)
        intensites.append(valeur)
    except Exception as e:
        print(e)
        pass
fic.close()

print(u"Nb. de séismes traités : ",len(phases))

plt.figure(figsize=(15, 13))
plt.scatter(phases, intensites,s=50)
plt.xlim((0,1))
plt.xlabel('Phase de la Lune(% de la surface illuminée)')
plt.ylabel(u'Intesité du seisme')
plt.savefig("repartition_seismes.png")
plt.show()

Quelques éléments sont ignorés (date non correcte ou intensité inconnue), le nombre total de séismes traités est de 304.

On obtient la jolie figure ci-dessous qui ressemble plus à une décharge de chevrotine qu’à l’une des lois statistiques usuelles…

Évolution de la surface illuminée de la Lune

Les plus têtus pourront remarquer une accumulation des points aux extrêmes. C’est simplement un effet dû à l’évolution de la surface illuminée qui n’est pas linéaire. Un petit script Python permet de tracer l’évolution de la surface illuminée en fonction du temps.

from datetime import datetime, timedelta
import ephem
import matplotlib.pyplot as plt

today = datetime.now()
dates = []
phases = []
for n in range(-50,50):
    # https://stackoverflow.com/questions/6871016/adding-5-days-to-a-date-in-python
    dates.append(today + timedelta(days=n))
    moon.compute(dates[-1])
    phases.append(moon.moon_phase)

plt.figure(figsize=(16, 9))
plt.plot(dates, phases,)
plt.xlim((today + timedelta(days=-50),today + timedelta(days=49)))
plt.ylim((0,1))
plt.xlabel('Date')
plt.ylabel('Phase de la Lune(% de la surface illuminée)')
plt.savefig("phases_Lune.png")
plt.show()

La figure obtenue à l’aspect ci-contre. Je n’ai pas fouillé dans les détails, mais je ne suis pas certain que ce soit une simple sinusoïde. Dans tous les cas, c’est non linéaire, ce qui explique « l’accumulation » des points aux extrêmes.

Il n’est donc pas possible d’affirmer que 80% des tremblements de terre ont lieu lors des phases de pleine Lune. Pour conclure sur une illustration simple à comprendre, je laisse le crayon à Randall Munroe.

La photo d’illustration est de Timo Newton-Syms from Helsinki, Finland and Chalfont St Giles, Bucks, UK — Super Moon

Installation

Téléchargement et installation du pilote

Les pilotes Canon sont téléchargés sur le site officiel, il n’est pas nécessaire de se promener sur le site, on peut le faire en ligne de commande :

wget http://gdlp01.c-wss.com/gds/6/0100004596/03/Linux_CAPT_PrinterDriver_V260_uk_EN.tar.gz

Il existe une version plus récente des pilotes (2.70), je ne l’ai pas testée.

L’archive obtenue contient plusieurs fichiers. Les paquets contenus dans 64-bit_Driver/Debian sont ceux qui nous intéressent. Les paquets  cndrvcups-common_2.60-1_amd64.deb et cndrvcups-capt_2.60-1_amd64.deb doivent d’abord être installés (et dans cet ordre).

Paquets complémentaires

L’installation des paquets Canon n’est pas suffisante, il faut installer des paquets complémentaires pour l’architecture i386. Rien de bien méchant (une fois qu’on le sait…) :

sudo apt-get install libstdc++6:i386 libxml2:i386 zlib1g:i386 libpopt0:i386

Configuration et enregistrement du pilote

Pour commencer il faut rechercher sur quel port l’imprimante est branchée. La commande ls -l /dev/usb/ permet de trouver le port utilisé par l’imprimante. Par un des hasards de l’informatique ici, j’obtiens :

crw-rw---- 1 root lp 180, 1 sept. 8 18:32 lp1

L’imprimante est donc connecté sur lp1

sudo /usr/sbin/lpadmin -p LBP1120 -m CNCUPSLBP1120CAPTK.ppd -v ccp://localhost:59787 -E
sudo /usr/sbin/ccpdadmin -p LBP1120 -o /dev/usb/lp1
sudo /etc/init.d/ccpd restart

L’imprimante est alors accessible par le nom LBP1120 dans le gestionnaire d’imprimantes. Il fait laisser l’imprimante qui a été trouvée par Linux et la mettre en pause (sinon il va la redétecter à chaque démarrage). Ici, c’est celle qui est identifiée LASER-SHOT-LBP-1120.

Normalement la commande sudo /etc/init.d/ccpd status doit retourner deux valeurs (ce sont des numéros de processus).

Automatisation des commandes

Pour éviter de relancer les pilotes à la main à chaque démarrage du système on créé (ou complète) le fichier /etc/rc.local.

sudo vim /etc/rc.local

Dans ce fichier on ajoute les lignes suivantes :

sleep 120
/etc/init.d/ccpd stop
/etc/init.d/ccpd restart

Normalement, si l’imprimante est alimentée avant que le PC ne soit allumé, tout doit fonctionner.

Afficher l’état du pilote au démarrage

Dans le menu principal de Mint, aller sur le menu Applications au démarrage. Créer une nouvelle application en cliquant sur Ajouter. Les champs sont remplis avec les éléments suivant :

• Nom : Imprimante Canon (ou un truc comme ça ! )

Commande :   captstatusui  -P LBP1120 en ajoutant l’option -e la fenêtre n’apparaîtra qu’en cas d’erreur.

• Commentaire : comme vous voulez
• Délai d’exécution : 5, permet aux autres services d’être démarré avant, je ne sais pas si c’est indispensable mais ça marche comme ça, donc on change rien !

Liens utiles

• La procédure d’installation issue du forum Ubuntu (traduite par Google depuis le finnois !).
• Pour avoir l’interface graphique du pilote affichée en permanence je me suis inspiré de ce post.

Note du 2/10/2016 : de temps en temps l’imprimante n’est plus sur /dev/usb/lp1 mais repasse sur /dev/usb/lp0 sans explication. Un lien symbolique permet de résoudre le problème sudo ln -s /dev/usb/lp1 /dev/sub/lp0… C’est pas beau mais ça marche !

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer

Enregistrer