diff --git a/MyIA.AI.Notebooks/Search/Applications/CSP/App-5-Timetabling.ipynb b/MyIA.AI.Notebooks/Search/Applications/CSP/App-5-Timetabling.ipynb index 63a0bb7f77..2cdac62f1a 100644 --- a/MyIA.AI.Notebooks/Search/Applications/CSP/App-5-Timetabling.ipynb +++ b/MyIA.AI.Notebooks/Search/Applications/CSP/App-5-Timetabling.ipynb @@ -161,6 +161,13 @@ "print(f\"OR-Tools version: {cp_model.__name__} charge\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La cellule ci-dessus charge toutes les bibliothèques nécessaires au notebook : numpy pour les calculs, matplotlib pour les visualisations, et surtout OR-Tools CP-SAT (ortools.sat.python.cp_model) pour la résolution de contraintes. Le message 'Imports OK' confirme que toutes les dépendances sont disponibles dans l'environnement." + ] + }, { "cell_type": "markdown", "id": "cell-data-section", @@ -319,6 +326,13 @@ " print(f\" {name:<12} {info['capacity']:>10} {info['equipment']:<12}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les données définissent un problème d'emploi du temps réaliste avec 8 cours (Algo, Probas, Systemes, Reseaux, BDD, IA, Securite, Web), 4 salles (Amphi_A, Salle_B, Labo_C, Labo_D), 20 créneaux horaires répartis sur 5 jours avec 4 créneaux par jour, et 4 enseignants (Dupont, Martin, Bernard, Leroy). Chaque cours a des contraintes spécifiques : nombre d'étudiants, enseignant attitré, et équipement requis (standard ou labo)." + ] + }, { "cell_type": "markdown", "id": "cell-data-interpretation", @@ -462,6 +476,13 @@ " print(f\" {tname:<10} : {courses}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "L'analyse de compatibilité révèle que certains cours sont fortement contraints : Algo, Probas, BDD et IA n'ont qu'une seule salle compatible (Amphi_A) en raison de leur nombre élevé d'étudiants. Les cours Reseaux, Securite et Web nécessitent des salles avec équipement labo. Dupont enseigne Algo et Systemes, Martin enseigne Probas et IA, Bernard enseigne Reseaux et Securite, et Leroy enseigne BDD et Web." + ] + }, { "cell_type": "markdown", "id": "xlhn6ehqcw", @@ -650,6 +671,13 @@ "print(\"Fonctions de visualisation et d'evaluation definies.\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les fonctions utilitaires définies ici permettent de visualiser l'emploi du temps sous forme de tableau et d'évaluer sa qualité selon plusieurs métriques : trous enseignants (créneau inoccupé entre deux cours d'un même enseignant — à ne pas confondre avec le conflit salle, où deux cours occupent la même salle au même créneau), et équilibre de charge entre les jours. Les métriques imprimées plus bas en feront la différence : le glouton rendra 1 trou, CP-SAT 0." + ] + }, { "cell_type": "markdown", "id": "cell-greedy-section", @@ -803,6 +831,13 @@ " print(f\" {cname:<12} {rname:<12} {slot_label(slot)}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "L'heuristique gloutonne a réussi à placer les 8 cours en seulement 0,07 milliseconde. Elle fonctionne en triant d'abord les cours par contrainte décroissante, puis en leur affectant le premier créneau et salle disponibles. Tous les cours ont été placés avec succès." + ] + }, { "cell_type": "markdown", "id": "cell-greedy-visualization-intro", @@ -881,6 +916,13 @@ " print(\"Pas de solution gloutonne a visualiser.\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La visualisation graphique génère un tableau coloré montrant l'emploi du temps produit par l'heuristique gloutonne. Chaque cours apparaît avec sa salle et son créneau assignés, permettant de vérifier rapidement que les contraintes de capacité et d'équipement sont respectées." + ] + }, { "cell_type": "markdown", "id": "cell-greedy-interpretation", @@ -1141,6 +1183,13 @@ "print(\"Fonction solve_timetable_cpsat definie.\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La fonction solve_timetable_cpsat utilise le solveur de contraintes OR-Tools CP-SAT pour modéliser et résoudre le problème d'emploi du temps de manière optimale, garantissant l'optimalité par exploration systématique." + ] + }, { "cell_type": "markdown", "id": "cell-cpsat-execution-intro", @@ -1212,6 +1261,13 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La résolution par OR-Tools CP-SAT a trouvé une solution optimale pour le problème d'emploi du temps. Le statut OPTIMAL indique que le solveur a prouvé qu'aucune meilleure solution n'existe." + ] + }, { "cell_type": "markdown", "id": "e3kzsfeycpn", @@ -1288,6 +1344,13 @@ " print_metrics(cpsat_metrics, label=\"(CP-SAT)\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les métriques de qualité montrent que la solution CP-SAT a zéro trou enseignant et zéro conflit, validant que tous les enseignants sont disponibles pour leurs cours assignés et qu'aucune salle n'est utilisée simultanément." + ] + }, { "cell_type": "markdown", "id": "cell-cpsat-interpretation", @@ -1462,6 +1525,13 @@ " print(\"=\" * 55)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le tableau comparatif présente une analyse détaillée des solutions produites par les deux approches, montrant l'écart net entre les deux méthodes : trous enseignants 1 contre 0, cours le matin 75 % contre 100 %, écart-type des jours 3,20 contre 1,50, pour un temps de 0,07 ms (glouton) contre 32,5 ms (CP-SAT)." + ] + }, { "cell_type": "markdown", "id": "cell-comparison-interpretation", @@ -1699,6 +1769,13 @@ "print(MINIZINC_MODEL)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le modèle MiniZinc pour l'emploi du temps déclare les variables, les contraintes et l'objectif du problème dans un langage de modélisation standard. Ce modèle peut être utilisé avec différents solveurs." + ] + }, { "cell_type": "markdown", "id": "cell-minizinc-explanation", @@ -1820,6 +1897,13 @@ " os.unlink(mzn_path)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La tentative d'exécution du modèle MiniZinc échoue car le binaire minizinc n'est pas installé dans le PATH. Cela illustre l'importance des dépendances logicielles pour l'exécution." + ] + }, { "cell_type": "markdown", "id": "cell-minizinc-interpretation", @@ -1962,6 +2046,13 @@ " plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La cellule ci-dessus définit la vue « par enseignant » de l'emploi du temps (visualize_teacher_schedule) — une grille 2×2, un panneau par enseignant, où l'on lit directement ses créneaux occupés et ses trous. Aucune résolution ici : l'exécution MiniZinc a été écartée plus haut par l'imprimé (« MiniZinc non installe (binaire `minizinc` absent du PATH) ») — cette visualisation travaille sur les solutions glouton et CP-SAT déjà calculées." + ] + }, { "cell_type": "markdown", "id": "tepa1rpe4m9", @@ -2073,6 +2164,13 @@ " plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La cellule ci-dessus définit la dernière visualisation : l'heatmap d'utilisation des salles (visualize_room_utilization), une matrice salle × créneau où chaque cours occupé colore sa case. Ce n'est pas un solveur alternatif mais un regard croisé — combinée aux métriques imprimées (Amphi_A 4 cours soit 20 %, Salle_B et Labo_C 1 cours, Labo_D 2 cours), elle montre visuellement où se concentre la charge." + ] + }, { "cell_type": "markdown", "id": "cell-analysis-interpretation", @@ -2359,6 +2457,13 @@ "print(f\"Solution trouvee : {status}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La résolution CP-SAT avec les paramètres ajustés a trouvé une solution optimale en 50,9 ms, confirmant la faisabilité du problème avec les contraintes définies." + ] + }, { "cell_type": "markdown", "id": "a0df6895", @@ -2681,6 +2786,62 @@ "- Google OR-Tools : https://developers.google.com/optimization\n", "- MiniZinc : https://www.minizinc.org/" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le problème d'emploi du temps illustre parfaitement l'utilité des solveurs de contraintes pour les problèmes combinatoires complexes. Avec 8 cours, 4 salles, 20 créneaux et de nombreuses contraintes (capacité, équipement, disponibilité enseignants), l'espace de recherche théorique est de 1,68×10¹⁵ combinaisons, rendant une approche brute-force totalement irréaliste." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La comparaison entre l'heuristique gloutonne (0,07 ms) et CP-SAT (quelques ms) montre que pour ce problème, les deux approches trouvent des solutions valides. Cependant, CP-SAT garantit l'optimalité, ce qui est crucial pour les applications où la qualité de la solution est plus importante que la vitesse de calcul pure." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les métriques de qualité valident la solution CP-SAT : zéro trou enseignant, tous les cours le matin, répartition [2, 4, 2, 0, 0] sur les jours. La solution gloutonne, elle, reste valide (toutes les contraintes dures) mais rend 1 trou et entasse ses 8 cours sur le seul lundi — « valide » et « de qualité égale » sont deux choses distinctes, et c'est exactement ce que la colonne CP-SAT du tableau comparatif paie en 32,5 ms." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "L'approche par heuristique gloutonne, bien que rapide, ne garantit pas toujours l'optimalité. Cependant, pour ce problème spécifique, elle a réussi à trouver une solution valide en un temps record, ce qui démontre son utilité pour les cas où une solution rapide et acceptable est préférable à une solution optimale mais plus longue à calculer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le solveur CP-SAT d'OR-Tools utilise des algorithmes avancés de programmation par contraintes pour explorer efficacement l'espace de recherche. La solution optimale trouvée prouve que le problème est faisable avec les contraintes données, et que la configuration actuelle permet une planification parfaite sans conflits." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La visualisation de l'emploi du temps sous forme de tableau permet une vérification intuitive des résultats. On peut y voir que les cours sont répartis de manière à éviter les conflits de salles et de disponibilité des enseignants, confirmant ainsi le respect de toutes les contraintes du problème." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les problèmes de planification comme celui-ci sont omniprésents dans le monde réel : emplois du temps scolaires, horaires de transport, affectation de ressources, etc. Les solveurs de contraintes offrent une solution élégante et efficace pour ces problèmes combinatoires complexes." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En conclusion, ce notebook démontre deux approches complémentaires pour résoudre des problèmes de planification : les heuristiques rapides pour les solutions immédiates, et les solveurs de contraintes pour les solutions optimales et garanties. Le choix entre ces approches dépend des exigences spécifiques de l'application en termes de temps de calcul et de qualité de solution..." + ] } ], "metadata": { @@ -2718,4 +2879,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/MyIA.AI.Notebooks/Search/Part2-CSP/CSP-3-Advanced-Csharp.ipynb b/MyIA.AI.Notebooks/Search/Part2-CSP/CSP-3-Advanced-Csharp.ipynb index 7e97fae158..30d3032b3d 100644 --- a/MyIA.AI.Notebooks/Search/Part2-CSP/CSP-3-Advanced-Csharp.ipynb +++ b/MyIA.AI.Notebooks/Search/Part2-CSP/CSP-3-Advanced-Csharp.ipynb @@ -30,6 +30,13 @@ "**API Choco 4.10.17 vérifiées** par extraction bytecode du JAR (leçon C146)." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ce notebook présente des exemples avancés de résolution de problèmes de contraintes (CSP) en C# avec Choco-solver. Contrairement aux implémentations Python vues précédemment, l'utilisation de C# via IKVM permet de bénéficier des performances du solveur Java Choco tout en restant dans un écosystème .NET. Les exemples couvrent divers problèmes classiques : Sudoku, Cumulative, TSP, Table, et démontrent différentes techniques de modélisation et de résolution." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -55,7 +62,6 @@ " The below script needs to be able to find the current output cell; this is an easy method to get it.\r\n", " \r\n", " \r\n", @@ -197,6 +195,13 @@ "Console.WriteLine($\"Existe : {File.Exists(dllPath)}\");" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La première cellule charge la DLL Choco-solver (org.chocosolver.solver.dll) avec succès, confirmant que le fichier binaire est présent dans le système et accessible. La vérification 'Existe : True' valide que le chemin d'accès est correct et que le solveur de contraintes Java Choco peut être utilisé via l'interopérabilité .NET dans cet environnement C#." + ] + }, { "cell_type": "code", "execution_count": 2, @@ -275,6 +280,13 @@ "Console.WriteLine(\"IKVM 8.15.0 pret (home=\" + Path.GetFileName(ikvmHome) + \", tzdb=\" + tzdbOk + \") - Choco-solver charge\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "La cellule suivante initialise IKVM 8.15.0, une machine virtuelle Java pour .NET qui permet d'exécuter du code Java (comme Choco-solver) de manière transparente dans un environnement .NET. Le message indique que IKVM est prêt avec son répertoire d'installation complet et la prise en charge de la base de données de fuseaux horaires activée." + ] + }, { "cell_type": "markdown", "id": "b3fa7c34", @@ -325,6 +337,13 @@ "Console.WriteLine(\"Choco-solver 4.10.17 chargé via IKVM 8.15.0\");" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le chargement de Choco-solver 4.10.17 via IKVM 8.15.0 est maintenant confirmé et opérationnel. Cette version spécifique du solveur de contraintes open-source est désormais disponible pour résoudre des problèmes de satisfaction de contraintes (CSP) directement depuis le code C# exécuté dans ce notebook." + ] + }, { "cell_type": "markdown", "id": "4ba1f573", @@ -558,6 +577,13 @@ "Console.WriteLine(\"Verification : lignes/colonnes/blocs 2x2 contiennent tous 1-4\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le Mini-Sudoku 4x4 a été résolu avec succès en seulement 72 millisecondes, démontrant que le solveur Choco trouve efficacement une solution valide pour cette instance classique du problème de Sudoku. La solution satisfait toutes les contraintes du puzzle." + ] + }, { "cell_type": "markdown", "id": "fee0c66f", @@ -648,6 +674,13 @@ "Console.WriteLine(\"Instance C# (durees [3,4,2,5], cap 2) -> makespan 9 ; instance distincte du twin Python (makespan 6 sur [3,2,4,2] cap 2)\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le problème Cumulative 4/2 (4 tâches à ordonner sur 2 ressources avec contraintes de capacité) a été résolu en 76 ms avec un makespan de 9 unités de temps. Le makespan représente la durée totale nécessaire pour compléter toutes les tâches. Cette instance spécifique utilise des durées [3,4,2,5] et une capacité de 2, ce qui la distingue de son équivalent Python." + ] + }, { "cell_type": "markdown", "id": "c526abad", @@ -750,6 +783,13 @@ "Console.WriteLine(\"Optimum : 18 (plusieurs tours equivalents de cout 18).\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le problème du voyageur de commerce (TSP) avec 5 villes a été résolu en 17 millisecondes avec un coût total optimal de 18. Le tour trouvé est : 0 → 1 → 3 → 4 → 2 → 0. Il existe plusieurs tours équivalents avec ce même coût de 18, confirmant l'optimalité de la solution." + ] + }, { "cell_type": "markdown", "id": "0413eac6", @@ -821,6 +861,13 @@ "Console.WriteLine(\"(3 tuples autorises -> 3 solutions possibles, 1 renvoyee par solve())\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le problème Table (sélection d'une configuration PC respectant un budget et des contraintes de compatibilité) a été résolu en 2 ms. La solution optimale combine un disque dur (HDD) avec 16 Go de RAM et une alimentation de 750W. Il existait 3 tuples autorisés (combinations valides) possibles dans l'espace de recherche, mais la fonction solve() n'en a renvoyé qu'un seul." + ] + }, { "cell_type": "markdown", "id": "835c5534", @@ -941,6 +988,13 @@ "Console.WriteLine(\"d'explorer de grands voisinages sans re-optimiser tout le modele (approfondissement).\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "L'approche LNS (Large Neighborhood Search) a trouvé l'optimum global dès la première itération (it 0) avec un coût de 18, identique à la résolution directe. Le tour correspondant est : 0 → 1 → 3 → 4 → 2 → 0. Le temps de calcul de 1 ms démontre l'efficacité de cette méthode pour trouver rapidement des solutions de haute qualité sans ré-optimiser tout le modèle." + ] + }, { "cell_type": "markdown", "id": "56b301d6", @@ -1036,6 +1090,13 @@ "Console.WriteLine(\"XOR : exactement une des deux contraintes est satisfaite\");\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le problème de réification a été résolu en 5 millisecondes avec succès. La solution trouvée est x = 0, y = 1. La réification est une technique puissante en programmation par contraintes qui permet de rendre des expressions booléennes complexes explicites comme variables de décision, facilitant ainsi leur manipulation dans le modèle." + ] + }, { "cell_type": "markdown", "id": "029f9672", @@ -1340,6 +1401,13 @@ "Part of #4956 (marathon parité .NET ⇄ Python série CSP).\n", "See #4711 (jurisprudence IKVM 8.15.0 + Choco)." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les résultats présentés dans ce notebook démontrent que Choco-solver via IKVM offre une alternative performante et compatible .NET pour la résolution de problèmes de contraintes complexes. Les temps de résolution mesurés (de 1 à 76 ms) sont comparables aux implémentations Python tout en restant dans l'écosystème C#." + ] } ], "metadata": { @@ -1375,4 +1443,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file