Discussion :

[kaukau]

Salut!
Je m'intéresse à la transformation de programmes en haskell, vous auriez des pointeurs là-dessus?

Supposons que je veuille mettre au point des "agents intelligents" qui jouent à un jeu. Par exemple, le puissance 4.
Par "agent intelligent", je veux dire qu'il s'agit de programmes qui savent jouer au puissance 4, bien sur, mais qui savent en plus analyser la stratégie de l'adversaire... Et changer sa propre stratégie en conséquence.

Le joueur A à donc accès au code (la stratégie) du joueur B, et inversement.
Il va donc analyser le code du joueur B et changer sa propre stratégie en fonction: il devient le joueur A'. Le joueur B fait pareil, et il devient le joueur B'. Et ainsi de suite.

On a donc successivement les programmes suivants:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
rang 1: A                 B
rang 2: A.B              B.A
rang 3: (A.B).(B.A)    (B.A).(A.B)

Y a t'il des études qui ont été faites dans ce sens?
Quelles outils utiliser?
Vers quoi cela va converger?

[gorgonite]

pour ce genre de problèmes, je dirais que les techniques min-max ou systèmes de classeurs devraient suffire à "faire croire" qu'on a une certaine adaptation de sa stratégie, à un coût raisonnable

[kaukau]

Non non non l'objet de mon post était de parler de transformation de programmes en Haskell!!
Le puissance 4 était juste un prétexte...

[gorgonite]

Non non non l'objet de mon post était de parler de transformation de programmes en Haskell!!

qu'appelles-tu "transformation de programme" ?
si c'est évolution du comportement d'un programme donné en fonction des résultats obtenus, alors les techniques "évolutionnistes" de l'IA sont adaptées

[Garulfo]

C'est vague effectivement. Veux-tu dire « transformation de code source » ? Car ce que tu présentes se fait par des approches d'IA classiques.

[SpiceGuid]

Le joueur A à donc accès au code (la stratégie) du joueur B, et inversement.

C'est exactement comme le dit gorgonite, ton minimax (ou ton alpha-beta) peut utiliser une fonction d'évaluation pour le joueur A et une autre pour le joueur B. Ensuite, si ça t'amuse, tu peux imaginer un comportement évolutionnaire (j'aime pas "évolutionniste") sur les composantes de tes fonctions d'évaluations.

Le titre pourrait inciter à penser que ce dont tu parles c'est en fait de manipuler du code comme des données, auquel cas :

• tu te tromperais de langage, de système de types, et peut être même de paradigme, tout traiter comme des données c'est une approche réifiante plutôt que fonctionnelle même si bien entendu Scheme/Lisp peuvent très bien le faire
• à mon avis tu te tromperais de démarche, tu ne vas pas ajouter de l'autonomie en mécanisant l'écriture de la fonction d'évaluation, par contre tu es presque certain d'ajouter une source inépuisable d'Imbécilité Automatique

En résumé toute la force d'alpha-béta réside dans le fait que c'est une intelligence humaine qui conçoit les principaux composants de la fonction d'évaluation. De ce côté là, si tu reste autour de Haskell/Caml, attends toi à des opinions assez conservatrices.

[kaukau]

Effectivement c'est un peu vague!!
Je voulais juste initier une discussion sur la transformation de programmes en Haskell.
C'est à dire un programme, en Haskell, qui transforme un autre programme (son code), éventuellement en Haskell.
Par exemple, pour en extraire de la doc, faire de l'analyse statique, faire du refactoring etc.
C'est globalement un sujet qui m'intéresse, donc tout commentaire/pointeur est bienvenu.
Quelques questions en vrac:
Haskell supporte-t'il la réflection?
Comment programmeriez vous un algorithme génétique? Et un algorithme génétique qui agit sur des programmes?
Comment manipuler un programme en Haskell?


Pour en revenir à mon post initial, je voudrais inventer un jeu dans lequel les agents doivent lire le code de l'adversaire pour adapter leur propre stratégie.

[Jedai]

Généralement vu le but original, il me semblerait bien plus raisonnable de créer un petit EDSL pour exprimer les stratégies.

Néanmoins si tu tiens à aborder le sujet de la réflexion en Haskell, il y a plusieurs outils intéressants, d'une part il y a tout ce qui est programmation générique (SYB, Uniplate, EMGM...). Ensuite tu as Template Haskell (les macros typés, en Haskell) qui couplé avec un parser Haskell (comme celui fourni par haskell-src-ext) apporte des possibilités intéressantes. Enfin tu peux attaquer directement l'API GHC ou de façon plus raisonnable utiliser l'un des packages à l'interface un peu plus abordable comme intermédiaire et charger du code à l'exécution.

Je te souhaite bien du plaisir, il y a matière à faire des choses jolies dans le tas.

--
Jedaï

[kaukau]

Merci pour vos réponses.
En effet, un EDSL me semble approprié, bien que je n'ai aucune expérience dans ce domaine.
ya t'il des exemples d'EDSL pour exprimer des stratégies à un jeu?

[limestrael]

J'ai envie de dire LUA, mais bon, c'est quand même un langage de script plus qu'un EDSL, et puis pour interfacer ça avec Haskell, tu vas rigoler.

[Jedai]

J'ai envie de dire LUA, mais bon, c'est quand même un langage de script plus qu'un EDSL, et puis pour interfacer ça avec Haskell, tu vas rigoler.

Je ne pense pas que Lua soit vraiment adapté à exprimer des stratégies de jeu, tu confonds avec le fait que Lua soit utilisé en tant que langage de script pour un certain nombre de jeux vidéos, mais dans ces cas il est principalement utilisé pour faire des macros, ou des triggers, pas grand chose à voir avec de la stratégie globale.

--
Jedaï

[limestrael]

Je ne pense pas que Lua soit vraiment adapté à exprimer des stratégies de jeu, tu confonds avec le fait que Lua soit utilisé en tant que langage de script pour un certain nombre de jeux vidéos, mais dans ces cas il est principalement utilisé pour faire des macros, ou des triggers, pas grand chose à voir avec de la stratégie globale.

Ouaip, tu as sûrement raison. A vrai dire, j'ai pas trop pratiqué le scripting d'IA. Est-ce que CLisp (ou Scheme) serait adapté et facile à utiliser dans ce cas ? Pour définir une stratégie j'entends, pas pour faire de la transformation de programmes.