Explorer les techniques de résolution créative de problèmes pour des agents d'IA industriels, incluant le raisonnement analogique, la reformulation et l'exploration multi-modèles.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Explorer les techniques de résolution créative de problèmes pour des agents d'IA industriels, incluant le raisonnement analogique, la reformulation et l'exploration multi-modèles.
["Creative Problem Solving","CPS","raisonnement latéral","reformulation","exploration stratégies"]
Résolution Créative de Problèmes en IA
Vue d'ensemble
La résolution créative de problèmes (Creative Problem Solving — CPS) est un ensemble de méthodologies permettant à un agent IA de faire face à des situations inédites pour lesquelles aucune solution pré-encodée n'existe. Contrairement aux approches déterministes qui appliquent des règles fixes, la CPS mobilise des mécanismes de reformulation, de raisonnement analogique et d'exploration multi-modèles pour générer des solutions originales et adaptées au contexte.
Cette compétence est particulièrement critique dans les environnements industriels imprévisibles — pannes non documentées, configurations inédites, objectifs contradictoires — où les solutions connues échouent systématiquement.
Principes fondamentaux
Principe
Description
Divergence / Convergence
Générer un maximum d'idées (divergence), puis les filtrer (convergence)
Reformulation
Changer la représentation du problème pour débloquer des solutions
Analogie
Transposer une solution d'un domaine connu vers le problème actuel
Itération adaptative
Essai-erreur avec ajustement continu de la stratégie
Quand utiliser cette compétence
Scénario
Pertinence
Le problème rencontré n'a pas de solution documentée dans la base de connaissances
Élevée
Plusieurs approches contradictoires existent et doivent être évaluées
Élevée
Le problème implique des contraintes multiples et changeantes
Élevée
Une solution rapide (bricolée) est acceptable comme premier jet
Moyenne
La solution optimale est connue et peut être exécutée directement
Faible (préférer une exécution directe)
1. Reformulation des problèmes
1.1 Cadre de reformulation
La reformulation consiste à ré-encoder le problème sous un angle différent pour révéler des solutions cachées :
Problème initial : "Comment réduire la latence d'inférence ?"
↓
Reformulation 1 : "Comment exécuter le même calcul avec moins d'opérations ?"
Reformulation 2 : "Comment tolérer une latence plus élevée sans dégrader l'expérience ?"
Reformulation 3 : "Comment déporter une partie du calcul en parallèle ?"
↓
Nouvelles solutions (inaccessibles depuis l'énoncé initial)
1.2 Implémentation Python
import re
from typing importCallableclassReformulateurDeProbleme:
"""Moteur de reformulation utilisant des patrons de transformation linguistique."""
PATRONS = [
(r"réduire (.+)", "Comment tolérer {0} plus élevé sans conséquence ?"),
(r"augmenter (.+)", "Comment éliminer le besoin de {0} ?"),
(r"éviter (.+)", "Comment transformer {0} en avantage ?"),
(r"optimiser (.+)", "Comment supprimer complètement {0} ?"),
]
defreformuler(self, enonce: str) -> list[str]:
"""Génère des reformulations alternatives d'un problème.
Args:
enonce: Énoncé original du problème.
Returns:
Liste de reformulations.
"""
resultats = []
for patron, template inself.PATRONS:
match = re.search(patron, enonce, re.IGNORECASE)
ifmatch:
resultats.append(template.format(match.group(1)))
return resultats if resultats else [enonce]
# Exemple d'utilisation
reformulateur = ReformulateurDeProbleme()
reformulations = reformulateur.reformuler(
"Comment réduire la consommation mémoire du modèle ?"
)
for r in reformulations:
print(f"→ {r}")
2. Raisonnement analogique
2.1 Mécanisme de transfert跨-domaine
Le raisonnement analogique identifie des similarités structurelles entre le problème courant et un problème connu dans un autre domaine, puis adapte la solution.
Domaine source : Ordonnancement de tâches usine
↕ Analogie structurelle (graphe de dépendances, contraintes de ressources)
Domaine cible : Routage de paquets réseau
↕ Adaptation
Solution : Algorithme de plus court chemin avec fenêtres temporelles
2.2 Implémentation d'un moteur d'analogie simple
classMoteurAnalogique:
"""Moteur de raisonnement analogique basé sur des vecteurs de similarité."""def__init__(self):
self.base_connaissances = {
"flux_trafic_urbain": {
"concept": "régulation de flux avec feux tricolores",
"solution": "algorithme de contention avec priorités tournantes",
"vecteur": [1.0, 0.8, 0.3, 0.1],
},
"optimisation_stock": {
"concept": "gestion de stock avec demande variable",
"solution": "politique (s, S) avec seuil de réapprovisionnement",
"vecteur": [0.3, 0.2, 0.9, 0.7],
},
"ordonnancement_taches": {
"concept": "séquençage de tâches sur machines parallèles",
"solution": "algorithme glouton avec priorité EDD",
"vecteur": [0.7, 0.9, 0.4, 0.3],
},
}
deftrouver_analogie(self, probleme: str, vecteur_probleme: list[float]) -> str:
"""Trouve la meilleure analogie pour un problème donné.
Args:
probleme: Description textuelle du problème.
vecteur_probleme: Encodage vectoriel du problème (4 dimensions).
Returns:
Solution adaptée du domaine source le plus proche.
Raises:
ValueError: Si la base de connaissances est vide.
"""ifnotself.base_connaissances:
raise ValueError("La base de connaissances est vide.")
meilleur_score = -1.0
meilleure_solution = "Aucune analogie trouvée."for _, source inself.base_connaissances.items():
score = sum(
a * b for a, b inzip(vecteur_probleme, source["vecteur"])
) / (sum(v ** 2for v in vecteur_probleme) ** 0.5 *
sum(v ** 2for v in source["vecteur"]) ** 0.5)
if score > meilleur_score:
meilleur_score = score
meilleure_solution = (
f"Analogie avec '{source['concept']}' "f"(similarité: {score:.2f})\n"f"Solution adaptée : {source['solution']}"
)
return meilleure_solution
3. Exploration multi-modèles
3.1 Architecture de l'agent adaptatif
L'agent CPS ne se limite pas à un seul algorithme. Il maintient un portfolio de stratégies et les active selon le contexte :
import random
from abc import ABC, abstractmethod
from typing importAnyclassStrategie(ABC):
"""Interface de base pour une stratégie de résolution.""" @abstractmethoddefexecuter(self, probleme: dict) -> Any:
"""Exécute la stratégie sur le problème donné.""" @abstractmethoddefnom(self) -> str:
"""Retourne le nom de la stratégie."""classStrategieGloutonne(Strategie):
defexecuter(self, probleme: dict) -> Any:
valeurs = sorted(probleme.get("options", []), reverse=True)
return {"strategie": "gloutonne", "solution": valeurs[:1]}
defnom(self) -> str:
return"gloutonne"classStrategieRechercheLocale(Strategie):
defexecuter(self, probleme: dict) -> Any:
meilleur = None
meilleur_score = float("-inf")
for _ inrange(100):
candidat = random.choice(probleme.get("options", []))
if candidat > meilleur_score:
meilleur_score = candidat
meilleur = candidat
return {"strategie": "recherche_locale", "solution": [meilleur]}
defnom(self) -> str:
return"recherche_locale"classAgentCPS:
"""Agent de résolution créative de problèmes."""def__init__(self):
self.strategies: list[Strategie] = [
StrategieGloutonne(),
StrategieRechercheLocale(),
]
self.historique_performance: dict[str, float] = {}
defajouter_strategie(self, strategie: Strategie) -> None:
"""Ajoute une nouvelle stratégie au portfolio de l'agent."""self.strategies.append(strategie)
defresoudre(self, probleme: dict, profondeur: int = 3) -> list[dict]:
"""Tente de résoudre un problème en explorant plusieurs stratégies.
Args:
probleme: Dictionnaire décrivant le problème (clé 'options' pour les valeurs candidates).
profondeur: Nombre d'itérations d'exploration.
Returns:
Liste des tentatives ordonnées par score décroissant.
"""
tentatives = []
for _ inrange(profondeur):
for strategie inself.strategies:
resultat = strategie.executer(probleme)
score = abs(
resultat["solution"][0] - probleme.get("cible", 0)
) if resultat["solution"] elsefloat("inf")
tentatives.append((score, resultat))
self.historique_performance[strategie.nom()] = (
self.historique_performance.get(strategie.nom(), 0) + score
)
return [t for _, t insorted(tentatives, key=lambda x: x[0])]
4. Pièges courants (Pitfalls)
4.1 Convergence prématurée
Problème : L'agent sélectionne la première solution "acceptable" sans explorer suffisamment l'espace des possibles, passant à côté de solutions bien meilleures.
Solution : Imposez un temps minimum de divergence (phase d'exploration pure) avant toute convergence. Utilisez une politique epsilon-gloutonne : 30 % d'exploration aléatoire, 70 % d'exploitation.
4.2 Analogies forcées
Problème : Établir des analogies superficielles entre des domaines qui ne partagent qu'une similarité de surface (ex. comparer un réseau de neurones à un réseau social).
Solution : Validez l'analogie à trois niveaux : (1) similarité structurelle, (2) similarité de contrainte, (3) similarité d'objectif. Si un seul niveau est satisfait, rejetez l'analogie.
4.3 Paralysie par surcharge d'options
Problème : L'agent dispose de trop de stratégies et passe plus de temps à choisir qu'à résoudre.
Solution : Limitez le portfolio actif à 5 stratégies maximum. Utilisez un mécanisme de bandit manchot (Thompson Sampling) pour sélectionner la stratégie la plus prometteuse en fonction de l'historique.
4.4 Absence de critère d'arrêt
Problème : L'agent itère indéfiniment sans détecter qu'il a atteint une solution satisfaisante.
Solution : Définissez un critère d'arrêt explicite dès le début :
